/* Generated by Cython 0.29.32 */

#ifndef PY_SSIZE_T_CLEAN
#define PY_SSIZE_T_CLEAN
#endif /* PY_SSIZE_T_CLEAN */
#include "Python.h"
#ifndef Py_PYTHON_H
    #error Python headers needed to compile C extensions, please install development version of Python.
#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
    #error Cython requires Python 2.6+ or Python 3.3+.
#else
#define CYTHON_ABI "0_29_32"
#define CYTHON_HEX_VERSION 0x001D20F0
#define CYTHON_FUTURE_DIVISION 1
#include <stddef.h>
#ifndef offsetof
  #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
#endif
#if !defined(WIN32) && !defined(MS_WINDOWS)
  #ifndef __stdcall
    #define __stdcall
  #endif
  #ifndef __cdecl
    #define __cdecl
  #endif
  #ifndef __fastcall
    #define __fastcall
  #endif
#endif
#ifndef DL_IMPORT
  #define DL_IMPORT(t) t
#endif
#ifndef DL_EXPORT
  #define DL_EXPORT(t) t
#endif
#define __PYX_COMMA ,
#ifndef HAVE_LONG_LONG
  #if PY_VERSION_HEX >= 0x02070000
    #define HAVE_LONG_LONG
  #endif
#endif
#ifndef PY_LONG_LONG
  #define PY_LONG_LONG LONG_LONG
#endif
#ifndef Py_HUGE_VAL
  #define Py_HUGE_VAL HUGE_VAL
#endif
#ifdef PYPY_VERSION
  #define CYTHON_COMPILING_IN_PYPY 1
  #define CYTHON_COMPILING_IN_PYSTON 0
  #define CYTHON_COMPILING_IN_CPYTHON 0
  #define CYTHON_COMPILING_IN_NOGIL 0
  #undef CYTHON_USE_TYPE_SLOTS
  #define CYTHON_USE_TYPE_SLOTS 0
  #undef CYTHON_USE_PYTYPE_LOOKUP
  #define CYTHON_USE_PYTYPE_LOOKUP 0
  #if PY_VERSION_HEX < 0x03050000
    #undef CYTHON_USE_ASYNC_SLOTS
    #define CYTHON_USE_ASYNC_SLOTS 0
  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
    #define CYTHON_USE_ASYNC_SLOTS 1
  #endif
  #undef CYTHON_USE_PYLIST_INTERNALS
  #define CYTHON_USE_PYLIST_INTERNALS 0
  #undef CYTHON_USE_UNICODE_INTERNALS
  #define CYTHON_USE_UNICODE_INTERNALS 0
  #undef CYTHON_USE_UNICODE_WRITER
  #define CYTHON_USE_UNICODE_WRITER 0
  #undef CYTHON_USE_PYLONG_INTERNALS
  #define CYTHON_USE_PYLONG_INTERNALS 0
  #undef CYTHON_AVOID_BORROWED_REFS
  #define CYTHON_AVOID_BORROWED_REFS 1
  #undef CYTHON_ASSUME_SAFE_MACROS
  #define CYTHON_ASSUME_SAFE_MACROS 0
  #undef CYTHON_UNPACK_METHODS
  #define CYTHON_UNPACK_METHODS 0
  #undef CYTHON_FAST_THREAD_STATE
  #define CYTHON_FAST_THREAD_STATE 0
  #undef CYTHON_FAST_PYCALL
  #define CYTHON_FAST_PYCALL 0
  #undef CYTHON_PEP489_MULTI_PHASE_INIT
  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
  #undef CYTHON_USE_TP_FINALIZE
  #define CYTHON_USE_TP_FINALIZE 0
  #undef CYTHON_USE_DICT_VERSIONS
  #define CYTHON_USE_DICT_VERSIONS 0
  #undef CYTHON_USE_EXC_INFO_STACK
  #define CYTHON_USE_EXC_INFO_STACK 0
  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900)
  #endif
#elif defined(PYSTON_VERSION)
  #define CYTHON_COMPILING_IN_PYPY 0
  #define CYTHON_COMPILING_IN_PYSTON 1
  #define CYTHON_COMPILING_IN_CPYTHON 0
  #define CYTHON_COMPILING_IN_NOGIL 0
  #ifndef CYTHON_USE_TYPE_SLOTS
    #define CYTHON_USE_TYPE_SLOTS 1
  #endif
  #undef CYTHON_USE_PYTYPE_LOOKUP
  #define CYTHON_USE_PYTYPE_LOOKUP 0
  #undef CYTHON_USE_ASYNC_SLOTS
  #define CYTHON_USE_ASYNC_SLOTS 0
  #undef CYTHON_USE_PYLIST_INTERNALS
  #define CYTHON_USE_PYLIST_INTERNALS 0
  #ifndef CYTHON_USE_UNICODE_INTERNALS
    #define CYTHON_USE_UNICODE_INTERNALS 1
  #endif
  #undef CYTHON_USE_UNICODE_WRITER
  #define CYTHON_USE_UNICODE_WRITER 0
  #undef CYTHON_USE_PYLONG_INTERNALS
  #define CYTHON_USE_PYLONG_INTERNALS 0
  #ifndef CYTHON_AVOID_BORROWED_REFS
    #define CYTHON_AVOID_BORROWED_REFS 0
  #endif
  #ifndef CYTHON_ASSUME_SAFE_MACROS
    #define CYTHON_ASSUME_SAFE_MACROS 1
  #endif
  #ifndef CYTHON_UNPACK_METHODS
    #define CYTHON_UNPACK_METHODS 1
  #endif
  #undef CYTHON_FAST_THREAD_STATE
  #define CYTHON_FAST_THREAD_STATE 0
  #undef CYTHON_FAST_PYCALL
  #define CYTHON_FAST_PYCALL 0
  #undef CYTHON_PEP489_MULTI_PHASE_INIT
  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
  #undef CYTHON_USE_TP_FINALIZE
  #define CYTHON_USE_TP_FINALIZE 0
  #undef CYTHON_USE_DICT_VERSIONS
  #define CYTHON_USE_DICT_VERSIONS 0
  #undef CYTHON_USE_EXC_INFO_STACK
  #define CYTHON_USE_EXC_INFO_STACK 0
  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
  #endif
#elif defined(PY_NOGIL)
  #define CYTHON_COMPILING_IN_PYPY 0
  #define CYTHON_COMPILING_IN_PYSTON 0
  #define CYTHON_COMPILING_IN_CPYTHON 0
  #define CYTHON_COMPILING_IN_NOGIL 1
  #ifndef CYTHON_USE_TYPE_SLOTS
    #define CYTHON_USE_TYPE_SLOTS 1
  #endif
  #undef CYTHON_USE_PYTYPE_LOOKUP
  #define CYTHON_USE_PYTYPE_LOOKUP 0
  #ifndef CYTHON_USE_ASYNC_SLOTS
    #define CYTHON_USE_ASYNC_SLOTS 1
  #endif
  #undef CYTHON_USE_PYLIST_INTERNALS
  #define CYTHON_USE_PYLIST_INTERNALS 0
  #ifndef CYTHON_USE_UNICODE_INTERNALS
    #define CYTHON_USE_UNICODE_INTERNALS 1
  #endif
  #undef CYTHON_USE_UNICODE_WRITER
  #define CYTHON_USE_UNICODE_WRITER 0
  #undef CYTHON_USE_PYLONG_INTERNALS
  #define CYTHON_USE_PYLONG_INTERNALS 0
  #ifndef CYTHON_AVOID_BORROWED_REFS
    #define CYTHON_AVOID_BORROWED_REFS 0
  #endif
  #ifndef CYTHON_ASSUME_SAFE_MACROS
    #define CYTHON_ASSUME_SAFE_MACROS 1
  #endif
  #ifndef CYTHON_UNPACK_METHODS
    #define CYTHON_UNPACK_METHODS 1
  #endif
  #undef CYTHON_FAST_THREAD_STATE
  #define CYTHON_FAST_THREAD_STATE 0
  #undef CYTHON_FAST_PYCALL
  #define CYTHON_FAST_PYCALL 0
  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
  #endif
  #ifndef CYTHON_USE_TP_FINALIZE
    #define CYTHON_USE_TP_FINALIZE 1
  #endif
  #undef CYTHON_USE_DICT_VERSIONS
  #define CYTHON_USE_DICT_VERSIONS 0
  #undef CYTHON_USE_EXC_INFO_STACK
  #define CYTHON_USE_EXC_INFO_STACK 0
#else
  #define CYTHON_COMPILING_IN_PYPY 0
  #define CYTHON_COMPILING_IN_PYSTON 0
  #define CYTHON_COMPILING_IN_CPYTHON 1
  #define CYTHON_COMPILING_IN_NOGIL 0
  #ifndef CYTHON_USE_TYPE_SLOTS
    #define CYTHON_USE_TYPE_SLOTS 1
  #endif
  #if PY_VERSION_HEX < 0x02070000
    #undef CYTHON_USE_PYTYPE_LOOKUP
    #define CYTHON_USE_PYTYPE_LOOKUP 0
  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
    #define CYTHON_USE_PYTYPE_LOOKUP 1
  #endif
  #if PY_MAJOR_VERSION < 3
    #undef CYTHON_USE_ASYNC_SLOTS
    #define CYTHON_USE_ASYNC_SLOTS 0
  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
    #define CYTHON_USE_ASYNC_SLOTS 1
  #endif
  #if PY_VERSION_HEX < 0x02070000
    #undef CYTHON_USE_PYLONG_INTERNALS
    #define CYTHON_USE_PYLONG_INTERNALS 0
  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
    #define CYTHON_USE_PYLONG_INTERNALS 1
  #endif
  #ifndef CYTHON_USE_PYLIST_INTERNALS
    #define CYTHON_USE_PYLIST_INTERNALS 1
  #endif
  #ifndef CYTHON_USE_UNICODE_INTERNALS
    #define CYTHON_USE_UNICODE_INTERNALS 1
  #endif
  #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2
    #undef CYTHON_USE_UNICODE_WRITER
    #define CYTHON_USE_UNICODE_WRITER 0
  #elif !defined(CYTHON_USE_UNICODE_WRITER)
    #define CYTHON_USE_UNICODE_WRITER 1
  #endif
  #ifndef CYTHON_AVOID_BORROWED_REFS
    #define CYTHON_AVOID_BORROWED_REFS 0
  #endif
  #ifndef CYTHON_ASSUME_SAFE_MACROS
    #define CYTHON_ASSUME_SAFE_MACROS 1
  #endif
  #ifndef CYTHON_UNPACK_METHODS
    #define CYTHON_UNPACK_METHODS 1
  #endif
  #if PY_VERSION_HEX >= 0x030B00A4
    #undef CYTHON_FAST_THREAD_STATE
    #define CYTHON_FAST_THREAD_STATE 0
  #elif !defined(CYTHON_FAST_THREAD_STATE)
    #define CYTHON_FAST_THREAD_STATE 1
  #endif
  #ifndef CYTHON_FAST_PYCALL
    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
  #endif
  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
  #endif
  #ifndef CYTHON_USE_TP_FINALIZE
    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
  #endif
  #ifndef CYTHON_USE_DICT_VERSIONS
    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
  #endif
  #if PY_VERSION_HEX >= 0x030B00A4
    #undef CYTHON_USE_EXC_INFO_STACK
    #define CYTHON_USE_EXC_INFO_STACK 0
  #elif !defined(CYTHON_USE_EXC_INFO_STACK)
    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
  #endif
  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
  #endif
#endif
#if !defined(CYTHON_FAST_PYCCALL)
#define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
#endif
#if CYTHON_USE_PYLONG_INTERNALS
  #if PY_MAJOR_VERSION < 3
    #include "longintrepr.h"
  #endif
  #undef SHIFT
  #undef BASE
  #undef MASK
  #ifdef SIZEOF_VOID_P
    enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
  #endif
#endif
#ifndef __has_attribute
  #define __has_attribute(x) 0
#endif
#ifndef __has_cpp_attribute
  #define __has_cpp_attribute(x) 0
#endif
#ifndef CYTHON_RESTRICT
  #if defined(__GNUC__)
    #define CYTHON_RESTRICT __restrict__
  #elif defined(_MSC_VER) && _MSC_VER >= 1400
    #define CYTHON_RESTRICT __restrict
  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define CYTHON_RESTRICT restrict
  #else
    #define CYTHON_RESTRICT
  #endif
#endif
#ifndef CYTHON_UNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define CYTHON_UNUSED __attribute__ ((__unused__))
#   else
#     define CYTHON_UNUSED
#   endif
# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
#   define CYTHON_UNUSED __attribute__ ((__unused__))
# else
#   define CYTHON_UNUSED
# endif
#endif
#ifndef CYTHON_MAYBE_UNUSED_VAR
#  if defined(__cplusplus)
     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
#  else
#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
#  endif
#endif
#ifndef CYTHON_NCP_UNUSED
# if CYTHON_COMPILING_IN_CPYTHON
#  define CYTHON_NCP_UNUSED
# else
#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
# endif
#endif
#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
#ifdef _MSC_VER
    #ifndef _MSC_STDINT_H_
        #if _MSC_VER < 1300
           typedef unsigned char     uint8_t;
           typedef unsigned int      uint32_t;
        #else
           typedef unsigned __int8   uint8_t;
           typedef unsigned __int32  uint32_t;
        #endif
    #endif
#else
   #include <stdint.h>
#endif
#ifndef CYTHON_FALLTHROUGH
  #if defined(__cplusplus) && __cplusplus >= 201103L
    #if __has_cpp_attribute(fallthrough)
      #define CYTHON_FALLTHROUGH [[fallthrough]]
    #elif __has_cpp_attribute(clang::fallthrough)
      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
    #elif __has_cpp_attribute(gnu::fallthrough)
      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
    #endif
  #endif
  #ifndef CYTHON_FALLTHROUGH
    #if __has_attribute(fallthrough)
      #define CYTHON_FALLTHROUGH __attribute__((fallthrough))
    #else
      #define CYTHON_FALLTHROUGH
    #endif
  #endif
  #if defined(__clang__ ) && defined(__apple_build_version__)
    #if __apple_build_version__ < 7000000
      #undef  CYTHON_FALLTHROUGH
      #define CYTHON_FALLTHROUGH
    #endif
  #endif
#endif

#ifndef CYTHON_INLINE
  #if defined(__clang__)
    #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
  #elif defined(__GNUC__)
    #define CYTHON_INLINE __inline__
  #elif defined(_MSC_VER)
    #define CYTHON_INLINE __inline
  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define CYTHON_INLINE inline
  #else
    #define CYTHON_INLINE
  #endif
#endif

#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
  #define Py_OptimizeFlag 0
#endif
#define __PYX_BUILD_PY_SSIZE_T "n"
#define CYTHON_FORMAT_SSIZE_T "z"
#if PY_MAJOR_VERSION < 3
  #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
  #define __Pyx_DefaultClassType PyClass_Type
#else
  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
  #define __Pyx_DefaultClassType PyType_Type
#if PY_VERSION_HEX >= 0x030B00A1
    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                    PyObject *fv, PyObject *cell, PyObject* fn,
                                                    PyObject *name, int fline, PyObject *lnos) {
        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
        const char *fn_cstr=NULL;
        const char *name_cstr=NULL;
        PyCodeObject* co=NULL;
        PyObject *type, *value, *traceback;
        PyErr_Fetch(&type, &value, &traceback);
        if (!(kwds=PyDict_New())) goto end;
        if (!(argcount=PyLong_FromLong(a))) goto end;
        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
        if (!(nlocals=PyLong_FromLong(l))) goto end;
        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
        if (!(stacksize=PyLong_FromLong(s))) goto end;
        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
        if (!(flags=PyLong_FromLong(f))) goto end;
        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
        Py_XDECREF((PyObject*)co);
        co = (PyCodeObject*)call_result;
        call_result = NULL;
        if (0) {
            cleanup_code_too:
            Py_XDECREF((PyObject*)co);
            co = NULL;
        }
        end:
        Py_XDECREF(kwds);
        Py_XDECREF(argcount);
        Py_XDECREF(posonlyargcount);
        Py_XDECREF(kwonlyargcount);
        Py_XDECREF(nlocals);
        Py_XDECREF(stacksize);
        Py_XDECREF(replace);
        Py_XDECREF(call_result);
        Py_XDECREF(empty);
        if (type) {
            PyErr_Restore(type, value, traceback);
        }
        return co;
    }
#else
  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
#endif
  #define __Pyx_DefaultClassType PyType_Type
#endif
#ifndef Py_TPFLAGS_CHECKTYPES
  #define Py_TPFLAGS_CHECKTYPES 0
#endif
#ifndef Py_TPFLAGS_HAVE_INDEX
  #define Py_TPFLAGS_HAVE_INDEX 0
#endif
#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
#endif
#ifndef Py_TPFLAGS_HAVE_FINALIZE
  #define Py_TPFLAGS_HAVE_FINALIZE 0
#endif
#ifndef METH_STACKLESS
  #define METH_STACKLESS 0
#endif
#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL)
  #ifndef METH_FASTCALL
     #define METH_FASTCALL 0x80
  #endif
  typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);
  typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                          Py_ssize_t nargs, PyObject *kwnames);
#else
  #define __Pyx_PyCFunctionFast _PyCFunctionFast
  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
#endif
#if CYTHON_FAST_PYCCALL
#define __Pyx_PyFastCFunction_Check(func)\
    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
#else
#define __Pyx_PyFastCFunction_Check(func) 0
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
  #define PyObject_Malloc(s)   PyMem_Malloc(s)
  #define PyObject_Free(p)     PyMem_Free(p)
  #define PyObject_Realloc(p)  PyMem_Realloc(p)
#endif
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
  #define PyMem_RawFree(p)             PyMem_Free(p)
#endif
#if CYTHON_COMPILING_IN_PYSTON
  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
#else
  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
#endif
#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
  #define __Pyx_PyThreadState_Current PyThreadState_GET()
#elif PY_VERSION_HEX >= 0x03060000
  #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
#elif PY_VERSION_HEX >= 0x03000000
  #define __Pyx_PyThreadState_Current PyThreadState_GET()
#else
  #define __Pyx_PyThreadState_Current _PyThreadState_Current
#endif
#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
#include "pythread.h"
#define Py_tss_NEEDS_INIT 0
typedef int Py_tss_t;
static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {
  *key = PyThread_create_key();
  return 0;
}
static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {
  Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t));
  *key = Py_tss_NEEDS_INIT;
  return key;
}
static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {
  PyObject_Free(key);
}
static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {
  return *key != Py_tss_NEEDS_INIT;
}
static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {
  PyThread_delete_key(*key);
  *key = Py_tss_NEEDS_INIT;
}
static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {
  return PyThread_set_key_value(*key, value);
}
static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
  return PyThread_get_key_value(*key);
}
#endif
#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
#define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
#else
#define __Pyx_PyDict_NewPresized(n)  PyDict_New()
#endif
#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION
  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
#else
  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
#endif
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
#else
#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
#endif
#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
  #define CYTHON_PEP393_ENABLED 1
  #if defined(PyUnicode_IS_READY)
  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
                                              0 : _PyUnicode_Ready((PyObject *)(op)))
  #else
  #define __Pyx_PyUnicode_READY(op)       (0)
  #endif
  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
  #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
  #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
  #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE)
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
  #else
  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
  #endif
  #else
  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
  #endif
#else
  #define CYTHON_PEP393_ENABLED 0
  #define PyUnicode_1BYTE_KIND  1
  #define PyUnicode_2BYTE_KIND  2
  #define PyUnicode_4BYTE_KIND  4
  #define __Pyx_PyUnicode_READY(op)       (0)
  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
  #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
  #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
#endif
#if CYTHON_COMPILING_IN_PYPY
  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
#else
  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
  #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
      PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
#endif
#define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
#define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
#else
  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
#endif
#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
  #define PyObject_ASCII(o)            PyObject_Repr(o)
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyBaseString_Type            PyUnicode_Type
  #define PyStringObject               PyUnicodeObject
  #define PyString_Type                PyUnicode_Type
  #define PyString_Check               PyUnicode_Check
  #define PyString_CheckExact          PyUnicode_CheckExact
#ifndef PyObject_Unicode
  #define PyObject_Unicode             PyObject_Str
#endif
#endif
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
#else
  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
#endif
#ifndef PySet_CheckExact
  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
#endif
#if PY_VERSION_HEX >= 0x030900A4
  #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
  #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)
#else
  #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
  #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
#endif
#if CYTHON_ASSUME_SAFE_MACROS
  #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
#else
  #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyIntObject                  PyLongObject
  #define PyInt_Type                   PyLong_Type
  #define PyInt_Check(op)              PyLong_Check(op)
  #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
  #define PyInt_FromString             PyLong_FromString
  #define PyInt_FromUnicode            PyLong_FromUnicode
  #define PyInt_FromLong               PyLong_FromLong
  #define PyInt_FromSize_t             PyLong_FromSize_t
  #define PyInt_FromSsize_t            PyLong_FromSsize_t
  #define PyInt_AsLong                 PyLong_AsLong
  #define PyInt_AS_LONG                PyLong_AS_LONG
  #define PyInt_AsSsize_t              PyLong_AsSsize_t
  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
  #define PyNumber_Int                 PyNumber_Long
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyBoolObject                 PyLongObject
#endif
#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
  #ifndef PyUnicode_InternFromString
    #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
  #endif
#endif
#if PY_VERSION_HEX < 0x030200A4
  typedef long Py_hash_t;
  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
  #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsHash_t
#else
  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
  #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
#endif
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
#else
  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
#endif
#if CYTHON_USE_ASYNC_SLOTS
  #if PY_VERSION_HEX >= 0x030500B1
    #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
    #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
  #else
    #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
  #endif
#else
  #define __Pyx_PyType_AsAsync(obj) NULL
#endif
#ifndef __Pyx_PyAsyncMethodsStruct
    typedef struct {
        unaryfunc am_await;
        unaryfunc am_aiter;
        unaryfunc am_anext;
    } __Pyx_PyAsyncMethodsStruct;
#endif

#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)
  #if !defined(_USE_MATH_DEFINES)
    #define _USE_MATH_DEFINES
  #endif
#endif
#include <math.h>
#ifdef NAN
#define __PYX_NAN() ((float) NAN)
#else
static CYTHON_INLINE float __PYX_NAN() {
  float value;
  memset(&value, 0xFF, sizeof(value));
  return value;
}
#endif
#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
#define __Pyx_truncl trunc
#else
#define __Pyx_truncl truncl
#endif

#define __PYX_MARK_ERR_POS(f_index, lineno) \
    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
#define __PYX_ERR(f_index, lineno, Ln_error) \
    { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }

#ifndef __PYX_EXTERN_C
  #ifdef __cplusplus
    #define __PYX_EXTERN_C extern "C"
  #else
    #define __PYX_EXTERN_C extern
  #endif
#endif

#define __PYX_HAVE__slepc4py__SLEPc
#define __PYX_HAVE_API__slepc4py__SLEPc
/* Early includes */
#include "slepc.h"
#include "petsc.h"
#include "compat.h"
#include "custom.h"
#include "scalar.h"
#include "slepc4py/numpy.h"
#include "petsc4py/numpy.h"
#include "string.h"
#include "stdio.h"
#ifdef _OPENMP
#include <omp.h>
#endif /* _OPENMP */

#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)
#define CYTHON_WITHOUT_ASSERTIONS
#endif

typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
                const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;

#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0
#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8)
#define __PYX_DEFAULT_STRING_ENCODING ""
#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#define __Pyx_uchar_cast(c) ((unsigned char)c)
#define __Pyx_long_cast(x) ((long)x)
#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
    (sizeof(type) < sizeof(Py_ssize_t))  ||\
    (sizeof(type) > sizeof(Py_ssize_t) &&\
          likely(v < (type)PY_SSIZE_T_MAX ||\
                 v == (type)PY_SSIZE_T_MAX)  &&\
          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
                                v == (type)PY_SSIZE_T_MIN)))  ||\
    (sizeof(type) == sizeof(Py_ssize_t) &&\
          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
                               v == (type)PY_SSIZE_T_MAX)))  )
static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
    return (size_t) i < (size_t) limit;
}
#if defined (__cplusplus) && __cplusplus >= 201103L
    #include <cstdlib>
    #define __Pyx_sst_abs(value) std::abs(value)
#elif SIZEOF_INT >= SIZEOF_SIZE_T
    #define __Pyx_sst_abs(value) abs(value)
#elif SIZEOF_LONG >= SIZEOF_SIZE_T
    #define __Pyx_sst_abs(value) labs(value)
#elif defined (_MSC_VER)
    #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value))
#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define __Pyx_sst_abs(value) llabs(value)
#elif defined (__GNUC__)
    #define __Pyx_sst_abs(value) __builtin_llabs(value)
#else
    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
#endif
static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
#define __Pyx_PyBytes_FromString        PyBytes_FromString
#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
#if PY_MAJOR_VERSION < 3
    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#else
    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
#endif
#define __Pyx_PyBytes_AsWritableString(s)     ((char*) PyBytes_AS_STRING(s))
#define __Pyx_PyBytes_AsWritableSString(s)    ((signed char*) PyBytes_AS_STRING(s))
#define __Pyx_PyBytes_AsWritableUString(s)    ((unsigned char*) PyBytes_AS_STRING(s))
#define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
#define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
#define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
#define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
#define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
    const Py_UNICODE *u_end = u;
    while (*u_end++) ;
    return (size_t)(u_end - u - 1);
}
#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
#define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
#define __Pyx_PySequence_Tuple(obj)\
    (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
#if CYTHON_ASSUME_SAFE_MACROS
#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
#else
#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
#endif
#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
#else
#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
#endif
#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
static int __Pyx_sys_getdefaultencoding_not_ascii;
static int __Pyx_init_sys_getdefaultencoding_params(void) {
    PyObject* sys;
    PyObject* default_encoding = NULL;
    PyObject* ascii_chars_u = NULL;
    PyObject* ascii_chars_b = NULL;
    const char* default_encoding_c;
    sys = PyImport_ImportModule("sys");
    if (!sys) goto bad;
    default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
    Py_DECREF(sys);
    if (!default_encoding) goto bad;
    default_encoding_c = PyBytes_AsString(default_encoding);
    if (!default_encoding_c) goto bad;
    if (strcmp(default_encoding_c, "ascii") == 0) {
        __Pyx_sys_getdefaultencoding_not_ascii = 0;
    } else {
        char ascii_chars[128];
        int c;
        for (c = 0; c < 128; c++) {
            ascii_chars[c] = c;
        }
        __Pyx_sys_getdefaultencoding_not_ascii = 1;
        ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
        if (!ascii_chars_u) goto bad;
        ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
        if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
            PyErr_Format(
                PyExc_ValueError,
                "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
                default_encoding_c);
            goto bad;
        }
        Py_DECREF(ascii_chars_u);
        Py_DECREF(ascii_chars_b);
    }
    Py_DECREF(default_encoding);
    return 0;
bad:
    Py_XDECREF(default_encoding);
    Py_XDECREF(ascii_chars_u);
    Py_XDECREF(ascii_chars_b);
    return -1;
}
#endif
#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
#else
#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
static char* __PYX_DEFAULT_STRING_ENCODING;
static int __Pyx_init_sys_getdefaultencoding_params(void) {
    PyObject* sys;
    PyObject* default_encoding = NULL;
    char* default_encoding_c;
    sys = PyImport_ImportModule("sys");
    if (!sys) goto bad;
    default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
    Py_DECREF(sys);
    if (!default_encoding) goto bad;
    default_encoding_c = PyBytes_AsString(default_encoding);
    if (!default_encoding_c) goto bad;
    __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1);
    if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
    strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
    Py_DECREF(default_encoding);
    return 0;
bad:
    Py_XDECREF(default_encoding);
    return -1;
}
#endif
#endif


/* Test for GCC > 2.95 */
#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
  #define likely(x)   __builtin_expect(!!(x), 1)
  #define unlikely(x) __builtin_expect(!!(x), 0)
#else /* !__GNUC__ or GCC < 2.95 */
  #define likely(x)   (x)
  #define unlikely(x) (x)
#endif /* __GNUC__ */
static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }

static PyObject *__pyx_m = NULL;
static PyObject *__pyx_d;
static PyObject *__pyx_b;
static PyObject *__pyx_cython_runtime = NULL;
static PyObject *__pyx_empty_tuple;
static PyObject *__pyx_empty_bytes;
static PyObject *__pyx_empty_unicode;
static int __pyx_lineno;
static int __pyx_clineno = 0;
static const char * __pyx_cfilenm= __FILE__;
static const char *__pyx_filename;


static const char *__pyx_f[] = {
  "SLEPc/ST.pyx",
  "SLEPc/allocate.pxi",
  "SLEPc/slepcbv.pxi",
  "SLEPc/slepceps.pxi",
  "SLEPc/SLEPc.pyx",
  "include/arraynpy.pxi",
  "SLEPc/slepcmpi.pxi",
  "SLEPc/slepcsys.pxi",
  "SLEPc/slepcsvd.pxi",
  "SLEPc/slepcpep.pxi",
  "SLEPc/slepcnep.pxi",
  "SLEPc/slepcmfn.pxi",
  "SLEPc/Sys.pyx",
  "SLEPc/BV.pyx",
  "SLEPc/DS.pyx",
  "SLEPc/FN.pyx",
  "SLEPc/RG.pyx",
  "SLEPc/EPS.pyx",
  "SLEPc/SVD.pyx",
  "SLEPc/PEP.pyx",
  "SLEPc/NEP.pyx",
  "SLEPc/MFN.pyx",
  "SLEPc/CAPI.pyx",
  "slepc4py.SLEPc.pyx",
  "PETSc.pxd",
};
/* ForceInitThreads.proto */
#ifndef __PYX_FORCE_INIT_THREADS
  #define __PYX_FORCE_INIT_THREADS 0
#endif

/* NoFastGil.proto */
#define __Pyx_PyGILState_Ensure PyGILState_Ensure
#define __Pyx_PyGILState_Release PyGILState_Release
#define __Pyx_FastGIL_Remember()
#define __Pyx_FastGIL_Forget()
#define __Pyx_FastGilFuncInit()


/*--- Type declarations ---*/
struct PyPetscCommObject;
struct PyPetscObjectObject;
struct PyPetscViewerObject;
struct PyPetscRandomObject;
struct PyPetscISObject;
struct PyPetscLGMapObject;
struct PyPetscSFObject;
struct PyPetscVecObject;
struct PyPetscSpaceObject;
struct PyPetscDualSpaceObject;
struct PyPetscFEObject;
struct PyPetscQuadObject;
struct PyPetscScatterObject;
struct PyPetscSectionObject;
struct PyPetscMatObject;
struct PyPetscMatPartitioningObject;
struct PyPetscNullSpaceObject;
struct PyPetscPCObject;
struct PyPetscKSPObject;
struct PyPetscSNESObject;
struct PyPetscTSObject;
struct PyPetscTAOObject;
struct PyPetscAOObject;
struct PyPetscDMObject;
struct PyPetscDSObject;
struct PyPetscPartitionerObject;
struct PyPetscDMLabelObject;
struct PySlepcSTObject;
struct PySlepcBVObject;
struct PySlepcDSObject;
struct PySlepcFNObject;
struct PySlepcRGObject;
struct PySlepcEPSObject;
struct PySlepcSVDObject;
struct PySlepcPEPObject;
struct PySlepcNEPObject;
struct PySlepcMFNObject;
struct __pyx_obj_8slepc4py_5SLEPc__p_mem;
struct __pyx_obj_8slepc4py_5SLEPc_Sys;

/* "petsc4py/PETSc.pxd":103
 * # --------------------------------------------------------------------
 * 
 * ctypedef public api class Comm [             # <<<<<<<<<<<<<<
 *     type   PyPetscComm_Type,
 *     object PyPetscCommObject,
 */
struct PyPetscCommObject {
  PyObject_HEAD
  MPI_Comm comm;
  int isdup;
  PyObject *base;
};
typedef struct PyPetscCommObject PyPetscCommObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscComm_Type;

/* "petsc4py/PETSc.pxd":111
 *     cdef object base
 * 
 * ctypedef public api class Object [             # <<<<<<<<<<<<<<
 *     type   PyPetscObject_Type,
 *     object PyPetscObjectObject,
 */
struct PyPetscObjectObject {
  PyObject_HEAD
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object *__pyx_vtab;
  PyObject *__weakref__;
  PyObject *__pyx___dummy__;
  PetscObject oval;
  PetscObject *obj;
};
typedef struct PyPetscObjectObject PyPetscObjectObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscObject_Type;

/* "petsc4py/PETSc.pxd":123
 *     cdef object get_dict(self)
 * 
 * ctypedef public api class Viewer(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscViewer_Type,
 *     object PyPetscViewerObject,
 */
struct PyPetscViewerObject {
  struct PyPetscObjectObject __pyx_base;
  PetscViewer vwr;
};
typedef struct PyPetscViewerObject PyPetscViewerObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscViewer_Type;

/* "petsc4py/PETSc.pxd":129
 *     cdef PetscViewer vwr
 * 
 * ctypedef public api class Random(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscRandom_Type,
 *     object PyPetscRandomObject,
 */
struct PyPetscRandomObject {
  struct PyPetscObjectObject __pyx_base;
  PetscRandom rnd;
};
typedef struct PyPetscRandomObject PyPetscRandomObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscRandom_Type;

/* "petsc4py/PETSc.pxd":135
 *     cdef PetscRandom rnd
 * 
 * ctypedef public api class IS(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscIS_Type,
 *     object PyPetscISObject,
 */
struct PyPetscISObject {
  struct PyPetscObjectObject __pyx_base;
  IS iset;
};
typedef struct PyPetscISObject PyPetscISObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscIS_Type;

/* "petsc4py/PETSc.pxd":141
 *     cdef PetscIS iset
 * 
 * ctypedef public api class LGMap(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscLGMap_Type,
 *     object PyPetscLGMapObject,
 */
struct PyPetscLGMapObject {
  struct PyPetscObjectObject __pyx_base;
  ISLocalToGlobalMapping lgm;
};
typedef struct PyPetscLGMapObject PyPetscLGMapObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscLGMap_Type;

/* "petsc4py/PETSc.pxd":147
 *     cdef PetscLGMap lgm
 * 
 * ctypedef public api class SF(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscSF_Type,
 *     object PyPetscSFObject,
 */
struct PyPetscSFObject {
  struct PyPetscObjectObject __pyx_base;
  PetscSF sf;
};
typedef struct PyPetscSFObject PyPetscSFObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscSF_Type;

/* "petsc4py/PETSc.pxd":153
 *     cdef PetscSF sf
 * 
 * ctypedef public api class Vec(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscVec_Type,
 *     object PyPetscVecObject,
 */
struct PyPetscVecObject {
  struct PyPetscObjectObject __pyx_base;
  Vec vec;
};
typedef struct PyPetscVecObject PyPetscVecObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscVec_Type;

/* "petsc4py/PETSc.pxd":159
 *     cdef PetscVec vec
 * 
 * ctypedef public api class Space(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscSpace_Type,
 *     object PyPetscSpaceObject,
 */
struct PyPetscSpaceObject {
  struct PyPetscObjectObject __pyx_base;
  PetscSpace space;
};
typedef struct PyPetscSpaceObject PyPetscSpaceObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscSpace_Type;

/* "petsc4py/PETSc.pxd":165
 *     cdef PetscSpace space
 * 
 * ctypedef public api class DualSpace(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscDualSpace_Type,
 *     object PyPetscDualSpaceObject,
 */
struct PyPetscDualSpaceObject {
  struct PyPetscObjectObject __pyx_base;
  PetscDualSpace dualspace;
};
typedef struct PyPetscDualSpaceObject PyPetscDualSpaceObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscDualSpace_Type;

/* "petsc4py/PETSc.pxd":171
 *     cdef PetscDualSpace dualspace
 * 
 * ctypedef public api class FE(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscFE_Type,
 *     object PyPetscFEObject,
 */
struct PyPetscFEObject {
  struct PyPetscObjectObject __pyx_base;
  PetscFE fe;
};
typedef struct PyPetscFEObject PyPetscFEObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscFE_Type;

/* "petsc4py/PETSc.pxd":177
 *     cdef PetscFE fe
 * 
 * ctypedef public api class Quad(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscQuad_Type,
 *     object PyPetscQuadObject,
 */
struct PyPetscQuadObject {
  struct PyPetscObjectObject __pyx_base;
  PetscQuadrature quad;
};
typedef struct PyPetscQuadObject PyPetscQuadObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscQuad_Type;

/* "petsc4py/PETSc.pxd":183
 *     cdef PetscQuadrature quad
 * 
 * ctypedef public api class Scatter(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscScatter_Type,
 *     object PyPetscScatterObject,
 */
struct PyPetscScatterObject {
  struct PyPetscObjectObject __pyx_base;
  VecScatter sct;
};
typedef struct PyPetscScatterObject PyPetscScatterObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscScatter_Type;

/* "petsc4py/PETSc.pxd":189
 *     cdef PetscScatter sct
 * 
 * ctypedef public api class Section(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscSection_Type,
 *     object PyPetscSectionObject,
 */
struct PyPetscSectionObject {
  struct PyPetscObjectObject __pyx_base;
  PetscSection sec;
};
typedef struct PyPetscSectionObject PyPetscSectionObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscSection_Type;

/* "petsc4py/PETSc.pxd":195
 *     cdef PetscSection sec
 * 
 * ctypedef public api class Mat(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscMat_Type,
 *     object PyPetscMatObject,
 */
struct PyPetscMatObject {
  struct PyPetscObjectObject __pyx_base;
  Mat mat;
};
typedef struct PyPetscMatObject PyPetscMatObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscMat_Type;

/* "petsc4py/PETSc.pxd":201
 *     cdef PetscMat mat
 * 
 * ctypedef public api class MatPartitioning(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscMatPartitioning_Type,
 *     object PyPetscMatPartitioningObject,
 */
struct PyPetscMatPartitioningObject {
  struct PyPetscObjectObject __pyx_base;
  MatPartitioning part;
};
typedef struct PyPetscMatPartitioningObject PyPetscMatPartitioningObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscMatPartitioning_Type;

/* "petsc4py/PETSc.pxd":207
 *     cdef PetscMatPartitioning part
 * 
 * ctypedef public api class NullSpace(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscNullSpace_Type,
 *     object PyPetscNullSpaceObject,
 */
struct PyPetscNullSpaceObject {
  struct PyPetscObjectObject __pyx_base;
  MatNullSpace nsp;
};
typedef struct PyPetscNullSpaceObject PyPetscNullSpaceObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscNullSpace_Type;

/* "petsc4py/PETSc.pxd":213
 *     cdef PetscNullSpace nsp
 * 
 * ctypedef public api class PC(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscPC_Type,
 *     object PyPetscPCObject,
 */
struct PyPetscPCObject {
  struct PyPetscObjectObject __pyx_base;
  PC pc;
};
typedef struct PyPetscPCObject PyPetscPCObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscPC_Type;

/* "petsc4py/PETSc.pxd":219
 *     cdef PetscPC pc
 * 
 * ctypedef public api class KSP(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscKSP_Type,
 *     object PyPetscKSPObject,
 */
struct PyPetscKSPObject {
  struct PyPetscObjectObject __pyx_base;
  KSP ksp;
};
typedef struct PyPetscKSPObject PyPetscKSPObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscKSP_Type;

/* "petsc4py/PETSc.pxd":225
 *     cdef PetscKSP ksp
 * 
 * ctypedef public api class SNES(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscSNES_Type,
 *     object PyPetscSNESObject,
 */
struct PyPetscSNESObject {
  struct PyPetscObjectObject __pyx_base;
  SNES snes;
};
typedef struct PyPetscSNESObject PyPetscSNESObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscSNES_Type;

/* "petsc4py/PETSc.pxd":231
 *     cdef PetscSNES snes
 * 
 * ctypedef public api class TS(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscTS_Type,
 *     object PyPetscTSObject,
 */
struct PyPetscTSObject {
  struct PyPetscObjectObject __pyx_base;
  TS ts;
};
typedef struct PyPetscTSObject PyPetscTSObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscTS_Type;

/* "petsc4py/PETSc.pxd":237
 *     cdef PetscTS ts
 * 
 * ctypedef public api class TAO(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscTAO_Type,
 *     object PyPetscTAOObject,
 */
struct PyPetscTAOObject {
  struct PyPetscObjectObject __pyx_base;
  Tao tao;
};
typedef struct PyPetscTAOObject PyPetscTAOObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscTAO_Type;

/* "petsc4py/PETSc.pxd":243
 *     cdef PetscTAO tao
 * 
 * ctypedef public api class AO(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscAO_Type,
 *     object PyPetscAOObject,
 */
struct PyPetscAOObject {
  struct PyPetscObjectObject __pyx_base;
  AO ao;
};
typedef struct PyPetscAOObject PyPetscAOObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscAO_Type;

/* "petsc4py/PETSc.pxd":249
 *     cdef PetscAO ao
 * 
 * ctypedef public api class DM(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscDM_Type,
 *     object PyPetscDMObject,
 */
struct PyPetscDMObject {
  struct PyPetscObjectObject __pyx_base;
  DM dm;
};
typedef struct PyPetscDMObject PyPetscDMObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscDM_Type;

/* "petsc4py/PETSc.pxd":255
 *     cdef PetscDM dm
 * 
 * ctypedef public api class DS(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscDS_Type,
 *     object PyPetscDSObject,
 */
struct PyPetscDSObject {
  struct PyPetscObjectObject __pyx_base;
  PetscDS ds;
};
typedef struct PyPetscDSObject PyPetscDSObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscDS_Type;

/* "petsc4py/PETSc.pxd":261
 *     cdef PetscDS ds
 * 
 * ctypedef public api class Partitioner(Object) [             # <<<<<<<<<<<<<<
 *     type PyPetscPartitioner_Type,
 *     object PyPetscPartitionerObject,
 */
struct PyPetscPartitionerObject {
  struct PyPetscObjectObject __pyx_base;
  PetscPartitioner part;
};
typedef struct PyPetscPartitionerObject PyPetscPartitionerObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscPartitioner_Type;

/* "petsc4py/PETSc.pxd":267
 *     cdef PetscPartitioner part
 * 
 * ctypedef public api class DMLabel(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscDMLabel_Type,
 *     object PyPetscDMLabelObject,
 */
struct PyPetscDMLabelObject {
  struct PyPetscObjectObject __pyx_base;
  DMLabel dmlabel;
};
typedef struct PyPetscDMLabelObject PyPetscDMLabelObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscDMLabel_Type;

/* "slepc4py/SLEPc.pxd":42
 * from petsc4py.PETSc cimport Object
 * 
 * ctypedef public api class ST(Object) [             # <<<<<<<<<<<<<<
 *     type   PySlepcST_Type,
 *     object PySlepcSTObject,
 */
struct PySlepcSTObject {
  struct PyPetscObjectObject __pyx_base;
  ST st;
};
typedef struct PySlepcSTObject PySlepcSTObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcST_Type;

/* "slepc4py/SLEPc.pxd":48
 *     cdef SlepcST st
 * 
 * ctypedef public api class BV(Object) [             # <<<<<<<<<<<<<<
 *     type   PySlepcBV_Type,
 *     object PySlepcBVObject,
 */
struct PySlepcBVObject {
  struct PyPetscObjectObject __pyx_base;
  BV bv;
};
typedef struct PySlepcBVObject PySlepcBVObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcBV_Type;

/* "slepc4py/SLEPc.pxd":54
 *     cdef SlepcBV bv
 * 
 * ctypedef public api class DS(Object) [             # <<<<<<<<<<<<<<
 *     type   PySlepcDS_Type,
 *     object PySlepcDSObject,
 */
struct PySlepcDSObject {
  struct PyPetscObjectObject __pyx_base;
  DS ds;
};
typedef struct PySlepcDSObject PySlepcDSObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcDS_Type;

/* "slepc4py/SLEPc.pxd":60
 *     cdef SlepcDS ds
 * 
 * ctypedef public api class FN(Object) [             # <<<<<<<<<<<<<<
 *     type   PySlepcFN_Type,
 *     object PySlepcFNObject,
 */
struct PySlepcFNObject {
  struct PyPetscObjectObject __pyx_base;
  FN fn;
};
typedef struct PySlepcFNObject PySlepcFNObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcFN_Type;

/* "slepc4py/SLEPc.pxd":66
 *     cdef SlepcFN fn
 * 
 * ctypedef public api class RG(Object) [             # <<<<<<<<<<<<<<
 *     type   PySlepcRG_Type,
 *     object PySlepcRGObject,
 */
struct PySlepcRGObject {
  struct PyPetscObjectObject __pyx_base;
  RG rg;
};
typedef struct PySlepcRGObject PySlepcRGObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcRG_Type;

/* "slepc4py/SLEPc.pxd":72
 *     cdef SlepcRG rg
 * 
 * ctypedef public api class EPS(Object) [             # <<<<<<<<<<<<<<
 *     type PySlepcEPS_Type,
 *     object PySlepcEPSObject,
 */
struct PySlepcEPSObject {
  struct PyPetscObjectObject __pyx_base;
  EPS eps;
};
typedef struct PySlepcEPSObject PySlepcEPSObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcEPS_Type;

/* "slepc4py/SLEPc.pxd":78
 *     cdef SlepcEPS eps
 * 
 * ctypedef public api class SVD(Object) [             # <<<<<<<<<<<<<<
 *     type   PySlepcSVD_Type,
 *     object PySlepcSVDObject,
 */
struct PySlepcSVDObject {
  struct PyPetscObjectObject __pyx_base;
  SVD svd;
};
typedef struct PySlepcSVDObject PySlepcSVDObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcSVD_Type;

/* "slepc4py/SLEPc.pxd":84
 *     cdef SlepcSVD svd
 * 
 * ctypedef public api class PEP(Object) [             # <<<<<<<<<<<<<<
 *     type   PySlepcPEP_Type,
 *     object PySlepcPEPObject,
 */
struct PySlepcPEPObject {
  struct PyPetscObjectObject __pyx_base;
  PEP pep;
};
typedef struct PySlepcPEPObject PySlepcPEPObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcPEP_Type;

/* "slepc4py/SLEPc.pxd":90
 *     cdef SlepcPEP pep
 * 
 * ctypedef public api class NEP(Object) [             # <<<<<<<<<<<<<<
 *     type   PySlepcNEP_Type,
 *     object PySlepcNEPObject,
 */
struct PySlepcNEPObject {
  struct PyPetscObjectObject __pyx_base;
  NEP nep;
};
typedef struct PySlepcNEPObject PySlepcNEPObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcNEP_Type;

/* "slepc4py/SLEPc.pxd":96
 *     cdef SlepcNEP nep
 * 
 * ctypedef public api class MFN(Object) [             # <<<<<<<<<<<<<<
 *     type   PySlepcMFN_Type,
 *     object PySlepcMFNObject,
 */
struct PySlepcMFNObject {
  struct PyPetscObjectObject __pyx_base;
  MFN mfn;
};
typedef struct PySlepcMFNObject PySlepcMFNObject;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcMFN_Type;

/* "SLEPc/allocate.pxi":11
 * #@cython.final
 * #@cython.internal
 * cdef class _p_mem:             # <<<<<<<<<<<<<<
 *     cdef void *buf
 *     def __cinit__(self):
 */
struct __pyx_obj_8slepc4py_5SLEPc__p_mem {
  PyObject_HEAD
  void *buf;
};


/* "SLEPc/Sys.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * cdef class Sys:             # <<<<<<<<<<<<<<
 * 
 *     @classmethod
 */
struct __pyx_obj_8slepc4py_5SLEPc_Sys {
  PyObject_HEAD
};


__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscObject_Type;

/* "petsc4py/PETSc.pxd":111
 *     cdef object base
 * 
 * ctypedef public api class Object [             # <<<<<<<<<<<<<<
 *     type   PyPetscObject_Type,
 *     object PyPetscObjectObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_Object {
  PyObject *(*get_attr)(struct PyPetscObjectObject *, char *);
  PyObject *(*set_attr)(struct PyPetscObjectObject *, char *, PyObject *);
  PyObject *(*get_dict)(struct PyPetscObjectObject *);
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_Object *__pyx_vtabptr_8petsc4py_5PETSc_Object;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscViewer_Type;

/* "petsc4py/PETSc.pxd":123
 *     cdef object get_dict(self)
 * 
 * ctypedef public api class Viewer(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscViewer_Type,
 *     object PyPetscViewerObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_Viewer {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_Viewer *__pyx_vtabptr_8petsc4py_5PETSc_Viewer;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscRandom_Type;

/* "petsc4py/PETSc.pxd":129
 *     cdef PetscViewer vwr
 * 
 * ctypedef public api class Random(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscRandom_Type,
 *     object PyPetscRandomObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_Random {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_Random *__pyx_vtabptr_8petsc4py_5PETSc_Random;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscIS_Type;

/* "petsc4py/PETSc.pxd":135
 *     cdef PetscRandom rnd
 * 
 * ctypedef public api class IS(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscIS_Type,
 *     object PyPetscISObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_IS {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_IS *__pyx_vtabptr_8petsc4py_5PETSc_IS;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscLGMap_Type;

/* "petsc4py/PETSc.pxd":141
 *     cdef PetscIS iset
 * 
 * ctypedef public api class LGMap(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscLGMap_Type,
 *     object PyPetscLGMapObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_LGMap {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_LGMap *__pyx_vtabptr_8petsc4py_5PETSc_LGMap;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscSF_Type;

/* "petsc4py/PETSc.pxd":147
 *     cdef PetscLGMap lgm
 * 
 * ctypedef public api class SF(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscSF_Type,
 *     object PyPetscSFObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_SF {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_SF *__pyx_vtabptr_8petsc4py_5PETSc_SF;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscVec_Type;

/* "petsc4py/PETSc.pxd":153
 *     cdef PetscSF sf
 * 
 * ctypedef public api class Vec(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscVec_Type,
 *     object PyPetscVecObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_Vec {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_Vec *__pyx_vtabptr_8petsc4py_5PETSc_Vec;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscSpace_Type;

/* "petsc4py/PETSc.pxd":159
 *     cdef PetscVec vec
 * 
 * ctypedef public api class Space(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscSpace_Type,
 *     object PyPetscSpaceObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_Space {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_Space *__pyx_vtabptr_8petsc4py_5PETSc_Space;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscDualSpace_Type;

/* "petsc4py/PETSc.pxd":165
 *     cdef PetscSpace space
 * 
 * ctypedef public api class DualSpace(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscDualSpace_Type,
 *     object PyPetscDualSpaceObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_DualSpace {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_DualSpace *__pyx_vtabptr_8petsc4py_5PETSc_DualSpace;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscFE_Type;

/* "petsc4py/PETSc.pxd":171
 *     cdef PetscDualSpace dualspace
 * 
 * ctypedef public api class FE(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscFE_Type,
 *     object PyPetscFEObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_FE {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_FE *__pyx_vtabptr_8petsc4py_5PETSc_FE;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscQuad_Type;

/* "petsc4py/PETSc.pxd":177
 *     cdef PetscFE fe
 * 
 * ctypedef public api class Quad(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscQuad_Type,
 *     object PyPetscQuadObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_Quad {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_Quad *__pyx_vtabptr_8petsc4py_5PETSc_Quad;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscScatter_Type;

/* "petsc4py/PETSc.pxd":183
 *     cdef PetscQuadrature quad
 * 
 * ctypedef public api class Scatter(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscScatter_Type,
 *     object PyPetscScatterObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_Scatter {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_Scatter *__pyx_vtabptr_8petsc4py_5PETSc_Scatter;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscSection_Type;

/* "petsc4py/PETSc.pxd":189
 *     cdef PetscScatter sct
 * 
 * ctypedef public api class Section(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscSection_Type,
 *     object PyPetscSectionObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_Section {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_Section *__pyx_vtabptr_8petsc4py_5PETSc_Section;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscMat_Type;

/* "petsc4py/PETSc.pxd":195
 *     cdef PetscSection sec
 * 
 * ctypedef public api class Mat(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscMat_Type,
 *     object PyPetscMatObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_Mat {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_Mat *__pyx_vtabptr_8petsc4py_5PETSc_Mat;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscMatPartitioning_Type;

/* "petsc4py/PETSc.pxd":201
 *     cdef PetscMat mat
 * 
 * ctypedef public api class MatPartitioning(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscMatPartitioning_Type,
 *     object PyPetscMatPartitioningObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_MatPartitioning {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_MatPartitioning *__pyx_vtabptr_8petsc4py_5PETSc_MatPartitioning;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscNullSpace_Type;

/* "petsc4py/PETSc.pxd":207
 *     cdef PetscMatPartitioning part
 * 
 * ctypedef public api class NullSpace(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscNullSpace_Type,
 *     object PyPetscNullSpaceObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_NullSpace {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_NullSpace *__pyx_vtabptr_8petsc4py_5PETSc_NullSpace;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscPC_Type;

/* "petsc4py/PETSc.pxd":213
 *     cdef PetscNullSpace nsp
 * 
 * ctypedef public api class PC(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscPC_Type,
 *     object PyPetscPCObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_PC {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_PC *__pyx_vtabptr_8petsc4py_5PETSc_PC;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscKSP_Type;

/* "petsc4py/PETSc.pxd":219
 *     cdef PetscPC pc
 * 
 * ctypedef public api class KSP(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscKSP_Type,
 *     object PyPetscKSPObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_KSP {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_KSP *__pyx_vtabptr_8petsc4py_5PETSc_KSP;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscSNES_Type;

/* "petsc4py/PETSc.pxd":225
 *     cdef PetscKSP ksp
 * 
 * ctypedef public api class SNES(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscSNES_Type,
 *     object PyPetscSNESObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_SNES {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_SNES *__pyx_vtabptr_8petsc4py_5PETSc_SNES;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscTS_Type;

/* "petsc4py/PETSc.pxd":231
 *     cdef PetscSNES snes
 * 
 * ctypedef public api class TS(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscTS_Type,
 *     object PyPetscTSObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_TS {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_TS *__pyx_vtabptr_8petsc4py_5PETSc_TS;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscTAO_Type;

/* "petsc4py/PETSc.pxd":237
 *     cdef PetscTS ts
 * 
 * ctypedef public api class TAO(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscTAO_Type,
 *     object PyPetscTAOObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_TAO {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_TAO *__pyx_vtabptr_8petsc4py_5PETSc_TAO;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscAO_Type;

/* "petsc4py/PETSc.pxd":243
 *     cdef PetscTAO tao
 * 
 * ctypedef public api class AO(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscAO_Type,
 *     object PyPetscAOObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_AO {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_AO *__pyx_vtabptr_8petsc4py_5PETSc_AO;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscDM_Type;

/* "petsc4py/PETSc.pxd":249
 *     cdef PetscAO ao
 * 
 * ctypedef public api class DM(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscDM_Type,
 *     object PyPetscDMObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_DM {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_DM *__pyx_vtabptr_8petsc4py_5PETSc_DM;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscDS_Type;

/* "petsc4py/PETSc.pxd":255
 *     cdef PetscDM dm
 * 
 * ctypedef public api class DS(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscDS_Type,
 *     object PyPetscDSObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_DS {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_DS *__pyx_vtabptr_8petsc4py_5PETSc_DS;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscPartitioner_Type;

/* "petsc4py/PETSc.pxd":261
 *     cdef PetscDS ds
 * 
 * ctypedef public api class Partitioner(Object) [             # <<<<<<<<<<<<<<
 *     type PyPetscPartitioner_Type,
 *     object PyPetscPartitionerObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_Partitioner {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_Partitioner *__pyx_vtabptr_8petsc4py_5PETSc_Partitioner;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PyPetscDMLabel_Type;

/* "petsc4py/PETSc.pxd":267
 *     cdef PetscPartitioner part
 * 
 * ctypedef public api class DMLabel(Object) [             # <<<<<<<<<<<<<<
 *     type   PyPetscDMLabel_Type,
 *     object PyPetscDMLabelObject,
 */

struct __pyx_vtabstruct_8petsc4py_5PETSc_DMLabel {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8petsc4py_5PETSc_DMLabel *__pyx_vtabptr_8petsc4py_5PETSc_DMLabel;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcST_Type;

/* "SLEPc/ST.pyx":36
 * # -----------------------------------------------------------------------------
 * 
 * cdef class ST(Object):             # <<<<<<<<<<<<<<
 * 
 *     """
 */

struct __pyx_vtabstruct_8slepc4py_5SLEPc_ST {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_ST *__pyx_vtabptr_8slepc4py_5SLEPc_ST;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcBV_Type;

/* "SLEPc/BV.pyx":75
 * # -----------------------------------------------------------------------------
 * 
 * cdef class BV(Object):             # <<<<<<<<<<<<<<
 * 
 *     """
 */

struct __pyx_vtabstruct_8slepc4py_5SLEPc_BV {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_BV *__pyx_vtabptr_8slepc4py_5SLEPc_BV;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcDS_Type;

/* "SLEPc/DS.pyx":76
 * # -----------------------------------------------------------------------------
 * 
 * cdef class DS(Object):             # <<<<<<<<<<<<<<
 * 
 *     """
 */

struct __pyx_vtabstruct_8slepc4py_5SLEPc_DS {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_DS *__pyx_vtabptr_8slepc4py_5SLEPc_DS;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcFN_Type;

/* "SLEPc/FN.pyx":41
 * # -----------------------------------------------------------------------------
 * 
 * cdef class FN(Object):             # <<<<<<<<<<<<<<
 * 
 *     """
 */

struct __pyx_vtabstruct_8slepc4py_5SLEPc_FN {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_FN *__pyx_vtabptr_8slepc4py_5SLEPc_FN;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcRG_Type;

/* "SLEPc/RG.pyx":24
 * # -----------------------------------------------------------------------------
 * 
 * cdef class RG(Object):             # <<<<<<<<<<<<<<
 * 
 *     """
 */

struct __pyx_vtabstruct_8slepc4py_5SLEPc_RG {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_RG *__pyx_vtabptr_8slepc4py_5SLEPc_RG;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcEPS_Type;

/* "SLEPc/EPS.pyx":247
 * # -----------------------------------------------------------------------------
 * 
 * cdef class EPS(Object):             # <<<<<<<<<<<<<<
 * 
 *     """
 */

struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *__pyx_vtabptr_8slepc4py_5SLEPc_EPS;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcSVD_Type;

/* "SLEPc/SVD.pyx":124
 * # -----------------------------------------------------------------------------
 * 
 * cdef class SVD(Object):             # <<<<<<<<<<<<<<
 * 
 *     """
 */

struct __pyx_vtabstruct_8slepc4py_5SLEPc_SVD {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_SVD *__pyx_vtabptr_8slepc4py_5SLEPc_SVD;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcPEP_Type;

/* "SLEPc/PEP.pyx":215
 * # -----------------------------------------------------------------------------
 * 
 * cdef class PEP(Object):             # <<<<<<<<<<<<<<
 * 
 *     """
 */

struct __pyx_vtabstruct_8slepc4py_5SLEPc_PEP {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_PEP *__pyx_vtabptr_8slepc4py_5SLEPc_PEP;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcNEP_Type;

/* "SLEPc/NEP.pyx":156
 * # -----------------------------------------------------------------------------
 * 
 * cdef class NEP(Object):             # <<<<<<<<<<<<<<
 * 
 *     """
 */

struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *__pyx_vtabptr_8slepc4py_5SLEPc_NEP;

__PYX_EXTERN_C DL_EXPORT(PyTypeObject) PySlepcMFN_Type;

/* "SLEPc/MFN.pyx":25
 * # -----------------------------------------------------------------------------
 * 
 * cdef class MFN(Object):             # <<<<<<<<<<<<<<
 * 
 *     """
 */

struct __pyx_vtabstruct_8slepc4py_5SLEPc_MFN {
  struct __pyx_vtabstruct_8petsc4py_5PETSc_Object __pyx_base;
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_MFN *__pyx_vtabptr_8slepc4py_5SLEPc_MFN;

/* --- Runtime support code (head) --- */
/* Refnanny.proto */
#ifndef CYTHON_REFNANNY
  #define CYTHON_REFNANNY 0
#endif
#if CYTHON_REFNANNY
  typedef struct {
    void (*INCREF)(void*, PyObject*, int);
    void (*DECREF)(void*, PyObject*, int);
    void (*GOTREF)(void*, PyObject*, int);
    void (*GIVEREF)(void*, PyObject*, int);
    void* (*SetupContext)(const char*, int, const char*);
    void (*FinishContext)(void**);
  } __Pyx_RefNannyAPIStruct;
  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
#ifdef WITH_THREAD
  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
          if (acquire_gil) {\
              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
              PyGILState_Release(__pyx_gilstate_save);\
          } else {\
              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
          }
#else
  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
#endif
  #define __Pyx_RefNannyFinishContext()\
          __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
#else
  #define __Pyx_RefNannyDeclarations
  #define __Pyx_RefNannySetupContext(name, acquire_gil)
  #define __Pyx_RefNannyFinishContext()
  #define __Pyx_INCREF(r) Py_INCREF(r)
  #define __Pyx_DECREF(r) Py_DECREF(r)
  #define __Pyx_GOTREF(r)
  #define __Pyx_GIVEREF(r)
  #define __Pyx_XINCREF(r) Py_XINCREF(r)
  #define __Pyx_XDECREF(r) Py_XDECREF(r)
  #define __Pyx_XGOTREF(r)
  #define __Pyx_XGIVEREF(r)
#endif
#define __Pyx_XDECREF_SET(r, v) do {\
        PyObject *tmp = (PyObject *) r;\
        r = v; __Pyx_XDECREF(tmp);\
    } while (0)
#define __Pyx_DECREF_SET(r, v) do {\
        PyObject *tmp = (PyObject *) r;\
        r = v; __Pyx_DECREF(tmp);\
    } while (0)
#define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
#define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)

/* PyObjectGetAttrStr.proto */
#if CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
#else
#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
#endif

/* GetBuiltinName.proto */
static PyObject *__Pyx_GetBuiltinName(PyObject *name);

/* decode_c_string_utf16.proto */
static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) {
    int byteorder = 0;
    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
}
static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) {
    int byteorder = -1;
    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
}
static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) {
    int byteorder = 1;
    return PyUnicode_DecodeUTF16(s, size, errors, &byteorder);
}

/* decode_c_bytes.proto */
static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes(
         const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop,
         const char* encoding, const char* errors,
         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors));

/* decode_bytes.proto */
static CYTHON_INLINE PyObject* __Pyx_decode_bytes(
         PyObject* string, Py_ssize_t start, Py_ssize_t stop,
         const char* encoding, const char* errors,
         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
    return __Pyx_decode_c_bytes(
        PyBytes_AS_STRING(string), PyBytes_GET_SIZE(string),
        start, stop, encoding, errors, decode_func);
}

/* PyFunctionFastCall.proto */
#if CYTHON_FAST_PYCALL
#define __Pyx_PyFunction_FastCall(func, args, nargs)\
    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
#if 1 || PY_VERSION_HEX < 0x030600B1
static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
#else
#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
#endif
#define __Pyx_BUILD_ASSERT_EXPR(cond)\
    (sizeof(char [1 - 2*!(cond)]) - 1)
#ifndef Py_MEMBER_SIZE
#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
#endif
#if CYTHON_FAST_PYCALL
  static size_t __pyx_pyframe_localsplus_offset = 0;
  #include "frameobject.h"
#if PY_VERSION_HEX >= 0x030b00a6
  #ifndef Py_BUILD_CORE
    #define Py_BUILD_CORE 1
  #endif
  #include "internal/pycore_frame.h"
#endif
  #define __Pxy_PyFrame_Initialize_Offsets()\
    ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
     (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
  #define __Pyx_PyFrame_GetLocalsplus(frame)\
    (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
#endif // CYTHON_FAST_PYCALL
#endif

/* PyObjectCall.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
#else
#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
#endif

/* PyObjectCallMethO.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
#endif

/* PyObjectCallNoArg.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
#else
#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
#endif

/* PyCFunctionFastCall.proto */
#if CYTHON_FAST_PYCCALL
static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
#else
#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
#endif

/* PyObjectCallOneArg.proto */
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);

/* RaiseArgTupleInvalid.proto */
static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);

/* KeywordStringCheck.proto */
static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed);

/* PyThreadStateGet.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
#else
#define __Pyx_PyThreadState_declare
#define __Pyx_PyThreadState_assign
#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
#endif

/* PyErrFetchRestore.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
#else
#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
#endif
#else
#define __Pyx_PyErr_Clear() PyErr_Clear()
#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
#endif

/* WriteUnraisableException.proto */
static void __Pyx_WriteUnraisable(const char *name, int clineno,
                                  int lineno, const char *filename,
                                  int full_traceback, int nogil);

/* RaiseTooManyValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);

/* RaiseNeedMoreValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);

/* IterFinish.proto */
static CYTHON_INLINE int __Pyx_IterFinish(void);

/* UnpackItemEndCheck.proto */
static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected);

/* GetTopmostException.proto */
#if CYTHON_USE_EXC_INFO_STACK
static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
#endif

/* SaveResetException.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_ExceptionSave(type, value, tb)  __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#define __Pyx_ExceptionReset(type, value, tb)  __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
#else
#define __Pyx_ExceptionSave(type, value, tb)   PyErr_GetExcInfo(type, value, tb)
#define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
#endif

/* PyErrExceptionMatches.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
#else
#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
#endif

/* GetException.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#else
static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
#endif

/* RaiseException.proto */
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);

/* ListCompAppend.proto */
#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
    PyListObject* L = (PyListObject*) list;
    Py_ssize_t len = Py_SIZE(list);
    if (likely(L->allocated > len)) {
        Py_INCREF(x);
        PyList_SET_ITEM(list, len, x);
        __Pyx_SET_SIZE(list, len + 1);
        return 0;
    }
    return PyList_Append(list, x);
}
#else
#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
#endif

/* RaiseDoubleKeywords.proto */
static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);

/* ParseKeywords.proto */
static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
    const char* function_name);

/* ListAppend.proto */
#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
    PyListObject* L = (PyListObject*) list;
    Py_ssize_t len = Py_SIZE(list);
    if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
        Py_INCREF(x);
        PyList_SET_ITEM(list, len, x);
        __Pyx_SET_SIZE(list, len + 1);
        return 0;
    }
    return PyList_Append(list, x);
}
#else
#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
#endif

/* PyObjectCall2Args.proto */
static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);

/* PyObjectGetMethod.proto */
static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);

/* PyObjectCallMethod1.proto */
static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg);

/* append.proto */
static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x);

/* GetItemInt.proto */
#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
    (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
               __Pyx_GetItemInt_Generic(o, to_py_func(i))))
#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
    (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
                                                              int wraparound, int boundscheck);
#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
    (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
                                                              int wraparound, int boundscheck);
static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
                                                     int is_list, int wraparound, int boundscheck);

/* ArgTypeTest.proto */
#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
    ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\
        __Pyx__ArgTypeTest(obj, type, name, exact))
static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);

/* ExtTypeTest.proto */
static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);

/* PyDictVersioning.proto */
#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
#define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
#define __PYX_GET_DICT_VERSION(dict)  (((PyDictObject*)(dict))->ma_version_tag)
#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
    (version_var) = __PYX_GET_DICT_VERSION(dict);\
    (cache_var) = (value);
#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
    static PY_UINT64_T __pyx_dict_version = 0;\
    static PyObject *__pyx_dict_cached_value = NULL;\
    if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
        (VAR) = __pyx_dict_cached_value;\
    } else {\
        (VAR) = __pyx_dict_cached_value = (LOOKUP);\
        __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
    }\
}
static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);
static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);
static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);
#else
#define __PYX_GET_DICT_VERSION(dict)  (0)
#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP)  (VAR) = (LOOKUP);
#endif

/* GetModuleGlobalName.proto */
#if CYTHON_USE_DICT_VERSIONS
#define __Pyx_GetModuleGlobalName(var, name)  {\
    static PY_UINT64_T __pyx_dict_version = 0;\
    static PyObject *__pyx_dict_cached_value = NULL;\
    (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\
        (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\
        __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
}
#define __Pyx_GetModuleGlobalNameUncached(var, name)  {\
    PY_UINT64_T __pyx_dict_version;\
    PyObject *__pyx_dict_cached_value;\
    (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
}
static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value);
#else
#define __Pyx_GetModuleGlobalName(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
#define __Pyx_GetModuleGlobalNameUncached(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
#endif

/* SwapException.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_ExceptionSwap(type, value, tb)  __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#else
static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb);
#endif

/* CallNextTpDealloc.proto */
static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc);

/* CallNextTpTraverse.proto */
static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse);

/* CallNextTpClear.proto */
static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_dealloc);

/* TypeImport.proto */
#ifndef __PYX_HAVE_RT_ImportType_proto
#define __PYX_HAVE_RT_ImportType_proto
enum __Pyx_ImportType_CheckSize {
   __Pyx_ImportType_CheckSize_Error = 0,
   __Pyx_ImportType_CheckSize_Warn = 1,
   __Pyx_ImportType_CheckSize_Ignore = 2
};
static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
#endif

/* GetVTable.proto */
static void* __Pyx_GetVtable(PyObject *dict);

/* PyObject_GenericGetAttrNoDict.proto */
#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
#else
#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr
#endif

/* PyObject_GenericGetAttr.proto */
#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name);
#else
#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr
#endif

/* SetVTable.proto */
static int __Pyx_SetVtable(PyObject *dict, void *vtable);

/* Import.proto */
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);

/* ImportFrom.proto */
static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);

/* ClassMethod.proto */
#include "descrobject.h"
static CYTHON_UNUSED PyObject* __Pyx_Method_ClassMethod(PyObject *method);

/* GetNameInClass.proto */
#define __Pyx_GetNameInClass(var, nmspace, name)  (var) = __Pyx__GetNameInClass(nmspace, name)
static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name);

/* CalculateMetaclass.proto */
static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases);

/* SetNameInClass.proto */
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
#define __Pyx_SetNameInClass(ns, name, value)\
    (likely(PyDict_CheckExact(ns)) ? _PyDict_SetItem_KnownHash(ns, name, value, ((PyASCIIObject *) name)->hash) : PyObject_SetItem(ns, name, value))
#elif CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_SetNameInClass(ns, name, value)\
    (likely(PyDict_CheckExact(ns)) ? PyDict_SetItem(ns, name, value) : PyObject_SetItem(ns, name, value))
#else
#define __Pyx_SetNameInClass(ns, name, value)  PyObject_SetItem(ns, name, value)
#endif

/* Py3ClassCreate.proto */
static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname,
                                           PyObject *mkw, PyObject *modname, PyObject *doc);
static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict,
                                      PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass);

/* PyObjectSetAttrStr.proto */
#if CYTHON_USE_TYPE_SLOTS
#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL)
static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value);
#else
#define __Pyx_PyObject_DelAttrStr(o,n)   PyObject_DelAttr(o,n)
#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v)
#endif

/* RegisterModuleCleanup.proto */
static void __pyx_module_cleanup(PyObject *self);
#if PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY
static int __Pyx_RegisterCleanup(void);
#else
#define __Pyx_RegisterCleanup() (0)
#endif

/* CLineInTraceback.proto */
#ifdef CYTHON_CLINE_IN_TRACEBACK
#define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
#else
static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
#endif

/* CodeObjectCache.proto */
typedef struct {
    PyCodeObject* code_object;
    int code_line;
} __Pyx_CodeObjectCacheEntry;
struct __Pyx_CodeObjectCache {
    int count;
    int max_count;
    __Pyx_CodeObjectCacheEntry* entries;
};
static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
static PyCodeObject *__pyx_find_code_object(int code_line);
static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);

/* AddTraceback.proto */
static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename);

/* GCCDiagnostics.proto */
#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
#define __Pyx_HAS_GCC_DIAGNOSTIC
#endif

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_STMatMode(STMatMode value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_BVOrthogType(BVOrthogType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_BVOrthogRefineType(BVOrthogRefineType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_BVOrthogBlockType(BVOrthogBlockType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_BVMatMultType(BVMatMultType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_BVSVDMethod(BVSVDMethod value);

/* CIntFromPy.proto */
static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_DSStateType(DSStateType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_DSMatType(DSMatType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_DSParallelType(DSParallelType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_FNCombineType(FNCombineType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_FNParallelType(FNParallelType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSCISSQuadRule(EPSCISSQuadRule value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSProblemType(EPSProblemType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSExtraction(EPSExtraction value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSBalance(EPSBalance value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSErrorType(EPSErrorType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSWhich(EPSWhich value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSConv(EPSConv value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSStop(EPSStop value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSConvergedReason(EPSConvergedReason value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSPowerShiftType(EPSPowerShiftType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSLanczosReorthogType(EPSLanczosReorthogType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSCISSExtraction(EPSCISSExtraction value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SVDProblemType(SVDProblemType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SVDErrorType(SVDErrorType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SVDWhich(SVDWhich value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SVDConv(SVDConv value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SVDStop(SVDStop value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SVDConvergedReason(SVDConvergedReason value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SVDTRLanczosGBidiag(SVDTRLanczosGBidiag value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPProblemType(PEPProblemType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPWhich(PEPWhich value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPBasis(PEPBasis value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPScale(PEPScale value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPRefine(PEPRefine value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPRefineScheme(PEPRefineScheme value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPExtract(PEPExtract value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPErrorType(PEPErrorType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPConv(PEPConv value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPStop(PEPStop value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPConvergedReason(PEPConvergedReason value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPJDProjection(PEPJDProjection value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPCISSExtraction(PEPCISSExtraction value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPProblemType(NEPProblemType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPErrorType(NEPErrorType value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPWhich(NEPWhich value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPConvergedReason(NEPConvergedReason value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPRefine(NEPRefine value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPRefineScheme(NEPRefineScheme value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPConv(NEPConv value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPStop(NEPStop value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPCISSExtraction(NEPCISSExtraction value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MFNConvergedReason(MFNConvergedReason value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PetscInt(PetscInt value);

/* CIntFromPy.proto */
static CYTHON_INLINE PetscInt __Pyx_PyInt_As_PetscInt(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE MatStructure __Pyx_PyInt_As_MatStructure(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE EPSConvergedReason __Pyx_PyInt_As_EPSConvergedReason(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE SVDConvergedReason __Pyx_PyInt_As_SVDConvergedReason(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE PEPConvergedReason __Pyx_PyInt_As_PEPConvergedReason(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE NEPConvergedReason __Pyx_PyInt_As_NEPConvergedReason(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE STMatMode __Pyx_PyInt_As_STMatMode(PyObject *);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MatStructure(MatStructure value);

/* CIntFromPy.proto */
static CYTHON_INLINE BVOrthogType __Pyx_PyInt_As_BVOrthogType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE BVOrthogRefineType __Pyx_PyInt_As_BVOrthogRefineType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE BVOrthogBlockType __Pyx_PyInt_As_BVOrthogBlockType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE BVMatMultType __Pyx_PyInt_As_BVMatMultType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE NormType __Pyx_PyInt_As_NormType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE DSStateType __Pyx_PyInt_As_DSStateType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE DSParallelType __Pyx_PyInt_As_DSParallelType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE DSMatType __Pyx_PyInt_As_DSMatType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE FNParallelType __Pyx_PyInt_As_FNParallelType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE FNCombineType __Pyx_PyInt_As_FNCombineType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE RGQuadRule __Pyx_PyInt_As_RGQuadRule(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE EPSProblemType __Pyx_PyInt_As_EPSProblemType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE EPSBalance __Pyx_PyInt_As_EPSBalance(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE EPSExtraction __Pyx_PyInt_As_EPSExtraction(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE EPSWhich __Pyx_PyInt_As_EPSWhich(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE EPSConv __Pyx_PyInt_As_EPSConv(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE EPSErrorType __Pyx_PyInt_As_EPSErrorType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE EPSPowerShiftType __Pyx_PyInt_As_EPSPowerShiftType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE EPSLanczosReorthogType __Pyx_PyInt_As_EPSLanczosReorthogType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE PetscBool __Pyx_PyInt_As_PetscBool(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE EPSCISSExtraction __Pyx_PyInt_As_EPSCISSExtraction(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE EPSCISSQuadRule __Pyx_PyInt_As_EPSCISSQuadRule(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE SVDProblemType __Pyx_PyInt_As_SVDProblemType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE SVDWhich __Pyx_PyInt_As_SVDWhich(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE SVDConv __Pyx_PyInt_As_SVDConv(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE SVDErrorType __Pyx_PyInt_As_SVDErrorType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE SVDTRLanczosGBidiag __Pyx_PyInt_As_SVDTRLanczosGBidiag(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE PEPBasis __Pyx_PyInt_As_PEPBasis(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE PEPProblemType __Pyx_PyInt_As_PEPProblemType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE PEPWhich __Pyx_PyInt_As_PEPWhich(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE PEPConv __Pyx_PyInt_As_PEPConv(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE PEPRefine __Pyx_PyInt_As_PEPRefine(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE PEPRefineScheme __Pyx_PyInt_As_PEPRefineScheme(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE PEPExtract __Pyx_PyInt_As_PEPExtract(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE PEPScale __Pyx_PyInt_As_PEPScale(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE PEPErrorType __Pyx_PyInt_As_PEPErrorType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE PEPJDProjection __Pyx_PyInt_As_PEPJDProjection(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE PEPCISSExtraction __Pyx_PyInt_As_PEPCISSExtraction(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE NEPProblemType __Pyx_PyInt_As_NEPProblemType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE NEPWhich __Pyx_PyInt_As_NEPWhich(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE NEPConv __Pyx_PyInt_As_NEPConv(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE NEPRefine __Pyx_PyInt_As_NEPRefine(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE NEPRefineScheme __Pyx_PyInt_As_NEPRefineScheme(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE NEPErrorType __Pyx_PyInt_As_NEPErrorType(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE NEPCISSExtraction __Pyx_PyInt_As_NEPCISSExtraction(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);

/* FastTypeChecks.proto */
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
#else
#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
#endif
#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)

/* CheckBinaryVersion.proto */
static int __Pyx_check_binary_version(void);

/* FunctionExport.proto */
static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig);

/* FunctionImport.proto */
static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig);

/* InitStrings.proto */
static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);


/* Module declarations from 'petsc4py.PETSc' */
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_Comm = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_Object = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_Viewer = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_Random = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_IS = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_LGMap = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_SF = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_Vec = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_Space = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_DualSpace = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_FE = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_Quad = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_Scatter = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_Section = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_Mat = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_MatPartitioning = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_NullSpace = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_PC = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_KSP = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_SNES = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_TS = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_TAO = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_AO = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_DM = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_DS = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_Partitioner = 0;
static PyTypeObject *__pyx_ptype_8petsc4py_5PETSc_DMLabel = 0;
static MPI_Comm (*__pyx_f_8petsc4py_5PETSc_GetComm)(PyObject *, MPI_Comm); /*proto*/
static MPI_Comm (*__pyx_f_8petsc4py_5PETSc_GetCommDefault)(void); /*proto*/
static int (*__pyx_f_8petsc4py_5PETSc_PyPetscType_Register)(int, PyTypeObject *); /*proto*/

/* Module declarations from 'cython' */

/* Module declarations from 'numpy' */

/* Module declarations from 'slepc4py.SLEPc' */
static PyTypeObject *__pyx_ptype_8slepc4py_5SLEPc_ST = 0;
static PyTypeObject *__pyx_ptype_8slepc4py_5SLEPc_BV = 0;
static PyTypeObject *__pyx_ptype_8slepc4py_5SLEPc_DS = 0;
static PyTypeObject *__pyx_ptype_8slepc4py_5SLEPc_FN = 0;
static PyTypeObject *__pyx_ptype_8slepc4py_5SLEPc_RG = 0;
static PyTypeObject *__pyx_ptype_8slepc4py_5SLEPc_EPS = 0;
static PyTypeObject *__pyx_ptype_8slepc4py_5SLEPc_SVD = 0;
static PyTypeObject *__pyx_ptype_8slepc4py_5SLEPc_PEP = 0;
static PyTypeObject *__pyx_ptype_8slepc4py_5SLEPc_NEP = 0;
static PyTypeObject *__pyx_ptype_8slepc4py_5SLEPc_MFN = 0;
static PyTypeObject *__pyx_ptype_8slepc4py_5SLEPc__p_mem = 0;
static PyTypeObject *__pyx_ptype_8slepc4py_5SLEPc_dtype = 0;
static PyTypeObject *__pyx_ptype_8slepc4py_5SLEPc_ndarray = 0;
static PyTypeObject *__pyx_ptype_8slepc4py_5SLEPc_Sys = 0;
static PyObject *__pyx_v_8slepc4py_5SLEPc_PetscError = 0;
static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_bytes2str(const char *); /*proto*/
static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_str2bytes(PyObject *, const char **); /*proto*/
static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_S_(const char *); /*proto*/
static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_allocate(size_t, void **); /*proto*/
static CYTHON_INLINE int __pyx_f_8slepc4py_5SLEPc_SETERR(int); /*proto*/
static CYTHON_INLINE int __pyx_f_8slepc4py_5SLEPc_CHKERR(int); /*proto*/
static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_toBool(PetscBool); /*proto*/
static CYTHON_INLINE PetscBool __pyx_f_8slepc4py_5SLEPc_asBool(PyObject *); /*proto*/
static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_toInt(PetscInt); /*proto*/
static CYTHON_INLINE PetscInt __pyx_f_8slepc4py_5SLEPc_asInt(PyObject *); /*proto*/
static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_toReal(PetscReal); /*proto*/
static CYTHON_INLINE PetscReal __pyx_f_8slepc4py_5SLEPc_asReal(PyObject *); /*proto*/
static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_toScalar(PetscScalar); /*proto*/
static CYTHON_INLINE PetscScalar __pyx_f_8slepc4py_5SLEPc_asScalar(PyObject *); /*proto*/
static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_toComplex(PetscScalar, PetscScalar); /*proto*/
static CYTHON_INLINE PetscReal __pyx_f_8slepc4py_5SLEPc_asComplexReal(PyObject *); /*proto*/
static CYTHON_INLINE PetscReal __pyx_f_8slepc4py_5SLEPc_asComplexImag(PyObject *); /*proto*/
static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_array_i(PetscInt, PetscInt const *); /*proto*/
static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_array_r(PetscInt, PetscReal const *); /*proto*/
static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_array_s(PetscInt, PetscScalar const *); /*proto*/
static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_iarray(PyObject *, int); /*proto*/
static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_iarray_r(PyObject *, PetscInt *, PetscReal **); /*proto*/
static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_iarray_s(PyObject *, PetscInt *, PetscScalar **); /*proto*/
static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_oarray(PyObject *, int); /*proto*/
static CYTHON_INLINE MPI_Comm __pyx_f_8slepc4py_5SLEPc_def_Comm(PyObject *, MPI_Comm); /*proto*/
static CYTHON_INLINE MPI_Comm __pyx_f_8slepc4py_5SLEPc_SLEPC_COMM_DEFAULT(void); /*proto*/
static CYTHON_INLINE MatStructure __pyx_f_8slepc4py_5SLEPc_matstructure(PyObject *); /*proto*/
static CYTHON_INLINE int __pyx_f_8slepc4py_5SLEPc_PetscINCREF(PetscObject *); /*proto*/
static CYTHON_INLINE int __pyx_f_8slepc4py_5SLEPc_SlepcCLEAR(PetscObject *); /*proto*/
static CYTHON_INLINE PetscViewer __pyx_f_8slepc4py_5SLEPc_def_Viewer(struct PyPetscViewerObject *); /*proto*/
static CYTHON_INLINE struct PyPetscKSPObject *__pyx_f_8slepc4py_5SLEPc_ref_KSP(KSP); /*proto*/
static CYTHON_INLINE struct PyPetscMatObject *__pyx_f_8slepc4py_5SLEPc_ref_Mat(Mat); /*proto*/
static CYTHON_INLINE struct PyPetscVecObject *__pyx_f_8slepc4py_5SLEPc_ref_Vec(Vec); /*proto*/
static CYTHON_INLINE int __pyx_f_8slepc4py_5SLEPc_BV_Sizes(PyObject *, PetscInt *, PetscInt *); /*proto*/
static CYTHON_INLINE struct PySlepcEPSObject *__pyx_f_8slepc4py_5SLEPc_ref_EPS(EPS); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_EPS_Stopping(EPS, PetscInt, PetscInt, PetscInt, PetscInt, EPSConvergedReason *, void *); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_EPS_Arbitrary(PetscScalar, PetscScalar, Vec, Vec, PetscScalar *, PetscScalar *, void *); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_EPS_Comparison(PetscScalar, PetscScalar, PetscScalar, PetscScalar, PetscInt *, void *); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_EPS_Monitor(EPS, PetscInt, PetscInt, PetscScalar *, PetscScalar *, PetscReal *, PetscInt, void *); /*proto*/
static CYTHON_INLINE struct PySlepcSVDObject *__pyx_f_8slepc4py_5SLEPc_ref_SVD(SVD); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_SVD_Stopping(SVD, PetscInt, PetscInt, PetscInt, PetscInt, SVDConvergedReason *, void *); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_SVD_Monitor(SVD, PetscInt, PetscInt, PetscReal *, PetscReal *, PetscInt, void *); /*proto*/
static CYTHON_INLINE struct PySlepcPEPObject *__pyx_f_8slepc4py_5SLEPc_ref_PEP(PEP); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_PEP_Stopping(PEP, PetscInt, PetscInt, PetscInt, PetscInt, PEPConvergedReason *, void *); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_PEP_Monitor(PEP, PetscInt, PetscInt, PetscScalar *, PetscScalar *, PetscReal *, PetscInt, void *); /*proto*/
static CYTHON_INLINE struct PySlepcNEPObject *__pyx_f_8slepc4py_5SLEPc_ref_NEP(NEP); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_NEP_Function(NEP, PetscScalar, Mat, Mat, void *); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_NEP_Jacobian(NEP, PetscScalar, Mat, void *); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_NEP_Stopping(NEP, PetscInt, PetscInt, PetscInt, PetscInt, NEPConvergedReason *, void *); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_NEP_Monitor(NEP, PetscInt, PetscInt, PetscScalar *, PetscScalar *, PetscReal *, PetscInt, void *); /*proto*/
static CYTHON_INLINE struct PySlepcMFNObject *__pyx_f_8slepc4py_5SLEPc_ref_MFN(MFN); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_MFN_Monitor(MFN, PetscInt, PetscReal, void *); /*proto*/
static CYTHON_INLINE int __pyx_f_8slepc4py_5SLEPc_setref(void *, void *); /*proto*/
static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcST_New(ST); /*proto*/
static ST __pyx_f_8slepc4py_5SLEPc_PySlepcST_Get(PyObject *); /*proto*/
static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcBV_New(BV); /*proto*/
static BV __pyx_f_8slepc4py_5SLEPc_PySlepcBV_Get(PyObject *); /*proto*/
static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcDS_New(DS); /*proto*/
static DS __pyx_f_8slepc4py_5SLEPc_PySlepcDS_Get(PyObject *); /*proto*/
static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcFN_New(FN); /*proto*/
static FN __pyx_f_8slepc4py_5SLEPc_PySlepcFN_Get(PyObject *); /*proto*/
static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcRG_New(RG); /*proto*/
static RG __pyx_f_8slepc4py_5SLEPc_PySlepcRG_Get(PyObject *); /*proto*/
static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcEPS_New(EPS); /*proto*/
static EPS __pyx_f_8slepc4py_5SLEPc_PySlepcEPS_Get(PyObject *); /*proto*/
static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcSVD_New(SVD); /*proto*/
static SVD __pyx_f_8slepc4py_5SLEPc_PySlepcSVD_Get(PyObject *); /*proto*/
static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcPEP_New(PEP); /*proto*/
static PEP __pyx_f_8slepc4py_5SLEPc_PySlepcPEP_Get(PyObject *); /*proto*/
static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcNEP_New(NEP); /*proto*/
static NEP __pyx_f_8slepc4py_5SLEPc_PySlepcNEP_Get(PyObject *); /*proto*/
static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcMFN_New(MFN); /*proto*/
static MFN __pyx_f_8slepc4py_5SLEPc_PySlepcMFN_Get(PyObject *); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_initialize(PyObject *); /*proto*/
static int __pyx_f_8slepc4py_5SLEPc_register(char *); /*proto*/
static void __pyx_f_8slepc4py_5SLEPc_finalize(void); /*proto*/
#define __Pyx_MODULE_NAME "slepc4py.SLEPc"
extern int __pyx_module_is_main_slepc4py__SLEPc;
int __pyx_module_is_main_slepc4py__SLEPc = 0;

/* Implementation of 'slepc4py.SLEPc' */
static PyObject *__pyx_builtin_object;
static PyObject *__pyx_builtin_MemoryError;
static PyObject *__pyx_builtin_TypeError;
static PyObject *__pyx_builtin_ValueError;
static PyObject *__pyx_builtin_range;
static const char __pyx_k_A[] = "A";
static const char __pyx_k_B[] = "B";
static const char __pyx_k_C[] = "C";
static const char __pyx_k_D[] = "D";
static const char __pyx_k_F[] = "F";
static const char __pyx_k_J[] = "J";
static const char __pyx_k_P[] = "P";
static const char __pyx_k_Q[] = "Q";
static const char __pyx_k_R[] = "R";
static const char __pyx_k_T[] = "T";
static const char __pyx_k_U[] = "U";
static const char __pyx_k_V[] = "V";
static const char __pyx_k_W[] = "W";
static const char __pyx_k_X[] = "X";
static const char __pyx_k_Y[] = "Y";
static const char __pyx_k_Z[] = "Z";
static const char __pyx_k_a[] = "a";
static const char __pyx_k_b[] = "b";
static const char __pyx_k_c[] = "c";
static const char __pyx_k_d[] = "d";
static const char __pyx_k_e[] = "e";
static const char __pyx_k_f[] = "f";
static const char __pyx_k_i[] = "i";
static const char __pyx_k_j[] = "j";
static const char __pyx_k_k[] = "k";
static const char __pyx_k_l[] = "l";
static const char __pyx_k_m[] = "m";
static const char __pyx_k_n[] = "n";
static const char __pyx_k_p[] = "p";
static const char __pyx_k_q[] = "q";
static const char __pyx_k_r[] = "r";
static const char __pyx_k_s[] = "s";
static const char __pyx_k_t[] = "t";
static const char __pyx_k_v[] = "v";
static const char __pyx_k_w[] = "w";
static const char __pyx_k_x[] = "x";
static const char __pyx_k_y[] = "y";
static const char __pyx_k_Au[] = "Au";
static const char __pyx_k_BV[] = "BV";
static const char __pyx_k_Bu[] = "Bu";
static const char __pyx_k_DS[] = "DS";
static const char __pyx_k_Dl[] = "Dl";
static const char __pyx_k_Dr[] = "Dr";
static const char __pyx_k_FN[] = "FN";
static const char __pyx_k_GD[] = "GD";
static const char __pyx_k_GS[] = "GS";
static const char __pyx_k_JD[] = "JD";
static const char __pyx_k_QR[] = "QR";
static const char __pyx_k_RG[] = "RG";
static const char __pyx_k_ST[] = "ST";
static const char __pyx_k_Vi[] = "Vi";
static const char __pyx_k_Vr[] = "Vr";
static const char __pyx_k_Wi[] = "Wi";
static const char __pyx_k_Wr[] = "Wr";
static const char __pyx_k__2[] = ",";
static const char __pyx_k__4[] = "\n";
static const char __pyx_k_bs[] = "bs";
static const char __pyx_k_bv[] = "bv";
static const char __pyx_k_ds[] = "ds";
static const char __pyx_k_f1[] = "f1";
static const char __pyx_k_f2[] = "f2";
static const char __pyx_k_fn[] = "fn";
static const char __pyx_k_ip[] = "ip";
static const char __pyx_k_ld[] = "ld";
static const char __pyx_k_ms[] = "ms";
static const char __pyx_k_nc[] = "nc";
static const char __pyx_k_op[] = "op";
static const char __pyx_k_rg[] = "rg";
static const char __pyx_k_st[] = "st";
static const char __pyx_k_ABS[] = "ABS";
static const char __pyx_k_ADD[] = "ADD";
static const char __pyx_k_ALL[] = "ALL";
static const char __pyx_k_CAA[] = "CAA";
static const char __pyx_k_CGS[] = "CGS";
static const char __pyx_k_EPS[] = "EPS";
static const char __pyx_k_EXP[] = "EXP";
static const char __pyx_k_HEP[] = "HEP";
static const char __pyx_k_LOG[] = "LOG";
static const char __pyx_k_MAT[] = "MAT";
static const char __pyx_k_MBE[] = "MBE";
static const char __pyx_k_MFN[] = "MFN";
static const char __pyx_k_MGS[] = "MGS";
static const char __pyx_k_NEP[] = "NEP";
static const char __pyx_k_PEP[] = "PEP";
static const char __pyx_k_PHI[] = "PHI";
static const char __pyx_k_RAW[] = "RAW";
static const char __pyx_k_REL[] = "REL";
static const char __pyx_k_RII[] = "RII";
static const char __pyx_k_SLP[] = "SLP";
static const char __pyx_k_SVD[] = "SVD";
static const char __pyx_k_Sys[] = "Sys";
static const char __pyx_k_cct[] = "cct";
static const char __pyx_k_deg[] = "deg";
static const char __pyx_k_doc[] = "__doc__";
static const char __pyx_k_eps[] = "eps";
static const char __pyx_k_eta[] = "eta";
static const char __pyx_k_ext[] = "ext";
static const char __pyx_k_fix[] = "fix";
static const char __pyx_k_flg[] = "flg";
static const char __pyx_k_its[] = "its";
static const char __pyx_k_ksp[] = "ksp";
static const char __pyx_k_lag[] = "lag";
static const char __pyx_k_mat[] = "mat";
static const char __pyx_k_mpd[] = "mpd";
static const char __pyx_k_ncv[] = "ncv";
static const char __pyx_k_nev[] = "nev";
static const char __pyx_k_nsv[] = "nsv";
static const char __pyx_k_pbc[] = "pbc";
static const char __pyx_k_pep[] = "pep";
static const char __pyx_k_ref[] = "ref";
static const char __pyx_k_rkc[] = "rkc";
static const char __pyx_k_rkl[] = "rkl";
static const char __pyx_k_rnd[] = "rnd";
static const char __pyx_k_tau[] = "tau";
static const char __pyx_k_tol[] = "tol";
static const char __pyx_k_BOTH[] = "BOTH";
static const char __pyx_k_CHOL[] = "CHOL";
static const char __pyx_k_CISS[] = "CISS";
static const char __pyx_k_COPY[] = "COPY";
static const char __pyx_k_Conv[] = "Conv";
static const char __pyx_k_ELPA[] = "ELPA";
static const char __pyx_k_EVSL[] = "EVSL";
static const char __pyx_k_FULL[] = "FULL";
static const char __pyx_k_GHEP[] = "GHEP";
static const char __pyx_k_GSVD[] = "GSVD";
static const char __pyx_k_NHEP[] = "NHEP";
static const char __pyx_k_NONE[] = "NONE";
static const char __pyx_k_NORM[] = "NORM";
static const char __pyx_k_RING[] = "RING";
static const char __pyx_k_RITZ[] = "RITZ";
static const char __pyx_k_RQCG[] = "RQCG";
static const char __pyx_k_SQRT[] = "SQRT";
static const char __pyx_k_SVEC[] = "SVEC";
static const char __pyx_k_SVQB[] = "SVQB";
static const char __pyx_k_Stop[] = "Stop";
static const char __pyx_k_TOAR[] = "TOAR";
static const char __pyx_k_TSQR[] = "TSQR";
static const char __pyx_k_Type[] = "Type";
static const char __pyx_k_USER[] = "USER";
static const char __pyx_k_VECS[] = "VECS";
static const char __pyx_k_args[] = "args";
static const char __pyx_k_beta[] = "beta";
static const char __pyx_k_comb[] = "comb";
static const char __pyx_k_comm[] = "comm";
static const char __pyx_k_comp[] = "comp";
static const char __pyx_k_conv[] = "conv";
static const char __pyx_k_copy[] = "copy";
static const char __pyx_k_date[] = "date";
static const char __pyx_k_flag[] = "flag";
static const char __pyx_k_herm[] = "herm";
static const char __pyx_k_inta[] = "inta";
static const char __pyx_k_intb[] = "intb";
static const char __pyx_k_keep[] = "keep";
static const char __pyx_k_lbda[] = "lbda";
static const char __pyx_k_left[] = "left";
static const char __pyx_k_lock[] = "lock";
static const char __pyx_k_main[] = "__main__";
static const char __pyx_k_meth[] = "meth";
static const char __pyx_k_minv[] = "minv";
static const char __pyx_k_mode[] = "mode";
static const char __pyx_k_name[] = "__name__";
static const char __pyx_k_orth[] = "orth";
static const char __pyx_k_proj[] = "proj";
static const char __pyx_k_quad[] = "quad";
static const char __pyx_k_spur[] = "spur";
static const char __pyx_k_trim[] = "trim";
static const char __pyx_k_BASIC[] = "BASIC";
static const char __pyx_k_Basis[] = "Basis";
static const char __pyx_k_CROSS[] = "CROSS";
static const char __pyx_k_Error[] = "Error";
static const char __pyx_k_FEAST[] = "FEAST";
static const char __pyx_k_GHIEP[] = "GHIEP";
static const char __pyx_k_GNHEP[] = "GNHEP";
static const char __pyx_k_LOCAL[] = "LOCAL";
static const char __pyx_k_LOWER[] = "LOWER";
static const char __pyx_k_MAXIT[] = "MAXIT";
static const char __pyx_k_NEVER[] = "NEVER";
static const char __pyx_k_POWER[] = "POWER";
static const char __pyx_k_SCHUR[] = "SCHUR";
static const char __pyx_k_SHELL[] = "SHELL";
static const char __pyx_k_SHIFT[] = "SHIFT";
static const char __pyx_k_STOAR[] = "STOAR";
static const char __pyx_k_Scale[] = "Scale";
static const char __pyx_k_TRLAN[] = "TRLAN";
static const char __pyx_k_UPPER[] = "UPPER";
static const char __pyx_k_Which[] = "Which";
static const char __pyx_k_alpha[] = "alpha";
static const char __pyx_k_basis[] = "basis";
static const char __pyx_k_block[] = "block";
static const char __pyx_k_borth[] = "borth";
static const char __pyx_k_bsmax[] = "bsmax";
static const char __pyx_k_condn[] = "condn";
static const char __pyx_k_delta[] = "delta";
static const char __pyx_k_devel[] = "devel";
static const char __pyx_k_etype[] = "etype";
static const char __pyx_k_getBV[] = "getBV";
static const char __pyx_k_getDS[] = "getDS";
static const char __pyx_k_getFN[] = "getFN";
static const char __pyx_k_getRG[] = "getRG";
static const char __pyx_k_getST[] = "getST";
static const char __pyx_k_indef[] = "indef";
static const char __pyx_k_inner[] = "inner";
static const char __pyx_k_kargs[] = "kargs";
static const char __pyx_k_major[] = "major";
static const char __pyx_k_maxit[] = "maxit";
static const char __pyx_k_minor[] = "minor";
static const char __pyx_k_npart[] = "npart";
static const char __pyx_k_nrest[] = "nrest";
static const char __pyx_k_omega[] = "omega";
static const char __pyx_k_otype[] = "otype";
static const char __pyx_k_p_mem[] = "_p_mem";
static const char __pyx_k_plusk[] = "plusk";
static const char __pyx_k_pmode[] = "pmode";
static const char __pyx_k_range[] = "range";
static const char __pyx_k_ready[] = "ready";
static const char __pyx_k_right[] = "right";
static const char __pyx_k_scale[] = "scale";
static const char __pyx_k_setBV[] = "setBV";
static const char __pyx_k_setDS[] = "setDS";
static const char __pyx_k_setRG[] = "setRG";
static const char __pyx_k_setST[] = "setST";
static const char __pyx_k_setUp[] = "setUp";
static const char __pyx_k_shift[] = "shift";
static const char __pyx_k_sizes[] = "sizes";
static const char __pyx_k_space[] = "space";
static const char __pyx_k_split[] = "split";
static const char __pyx_k_state[] = "state";
static const char __pyx_k_strip[] = "strip";
static const char __pyx_k_usest[] = "usest";
static const char __pyx_k_which[] = "which";
static const char __pyx_k_width[] = "width";
static const char __pyx_k_ALWAYS[] = "ALWAYS";
static const char __pyx_k_ARPACK[] = "ARPACK";
static const char __pyx_k_BLOPEX[] = "BLOPEX";
static const char __pyx_k_BVType[] = "BVType";
static const char __pyx_k_CAYLEY[] = "CAYLEY";
static const char __pyx_k_CYCLIC[] = "CYCLIC";
static const char __pyx_k_DECIDE[] = "DECIDE";
static const char __pyx_k_DIVIDE[] = "DIVIDE";
static const char __pyx_k_DSType[] = "DSType";
static const char __pyx_k_FILTER[] = "FILTER";
static const char __pyx_k_FNType[] = "FNType";
static const char __pyx_k_HANKEL[] = "HANKEL";
static const char __pyx_k_KRYLOV[] = "KRYLOV";
static const char __pyx_k_LAPACK[] = "LAPACK";
static const char __pyx_k_LINEAR[] = "LINEAR";
static const char __pyx_k_LOBPCG[] = "LOBPCG";
static const char __pyx_k_LYAPII[] = "LYAPII";
static const char __pyx_k_NHEPTS[] = "NHEPTS";
static const char __pyx_k_NLEIGS[] = "NLEIGS";
static const char __pyx_k_PGNHEP[] = "PGNHEP";
static const char __pyx_k_PRIMME[] = "PRIMME";
static const char __pyx_k_QR_CAA[] = "QR_CAA";
static const char __pyx_k_REFINE[] = "REFINE";
static const char __pyx_k_RGType[] = "RGType";
static const char __pyx_k_Refine[] = "Refine";
static const char __pyx_k_SCALAR[] = "SCALAR";
static const char __pyx_k_SIMPLE[] = "SIMPLE";
static const char __pyx_k_SINGLE[] = "SINGLE";
static const char __pyx_k_STType[] = "STType";
static const char __pyx_k_TENSOR[] = "TENSOR";
static const char __pyx_k_append[] = "append";
static const char __pyx_k_author[] = "author";
static const char __pyx_k_bidiag[] = "bidiag";
static const char __pyx_k_blsize[] = "blsize";
static const char __pyx_k_center[] = "center";
static const char __pyx_k_cutoff[] = "cutoff";
static const char __pyx_k_decode[] = "decode";
static const char __pyx_k_deftol[] = "deftol";
static const char __pyx_k_detect[] = "detect";
static const char __pyx_k_encode[] = "encode";
static const char __pyx_k_getKSP[] = "getKSP";
static const char __pyx_k_import[] = "__import__";
static const char __pyx_k_max_it[] = "max_it";
static const char __pyx_k_method[] = "method";
static const char __pyx_k_module[] = "__module__";
static const char __pyx_k_object[] = "object";
static const char __pyx_k_prefix[] = "prefix";
static const char __pyx_k_purify[] = "purify";
static const char __pyx_k_radius[] = "radius";
static const char __pyx_k_refine[] = "refine";
static const char __pyx_k_result[] = "result";
static const char __pyx_k_scheme[] = "scheme";
static const char __pyx_k_setKSP[] = "setKSP";
static const char __pyx_k_shifts[] = "shifts";
static const char __pyx_k_subint[] = "subint";
static const char __pyx_k_target[] = "target";
static const char __pyx_k_viewer[] = "viewer";
static const char __pyx_k_vscale[] = "vscale";
static const char __pyx_k_ARNOLDI[] = "ARNOLDI";
static const char __pyx_k_BV_type[] = "\n    BV type\n    ";
static const char __pyx_k_Balance[] = "Balance";
static const char __pyx_k_COMBINE[] = "COMBINE";
static const char __pyx_k_COMPOSE[] = "COMPOSE";
static const char __pyx_k_DEFAULT[] = "DEFAULT";
static const char __pyx_k_DELAYED[] = "DELAYED";
static const char __pyx_k_DS_type[] = "\n    DS type\n    ";
static const char __pyx_k_ELLIPSE[] = "ELLIPSE";
static const char __pyx_k_EPSConv[] = "EPSConv";
static const char __pyx_k_EPSStop[] = "EPSStop";
static const char __pyx_k_EPSType[] = "EPSType";
static const char __pyx_k_EXPOKIT[] = "EXPOKIT";
static const char __pyx_k_Extract[] = "Extract";
static const char __pyx_k_FN_type[] = "\n    FN type\n    ";
static const char __pyx_k_GENERAL[] = "GENERAL";
static const char __pyx_k_HERMITE[] = "HERMITE";
static const char __pyx_k_INPLACE[] = "INPLACE";
static const char __pyx_k_INVSQRT[] = "INVSQRT";
static const char __pyx_k_IntType[] = "IntType";
static const char __pyx_k_LANCZOS[] = "LANCZOS";
static const char __pyx_k_LARGEST[] = "LARGEST";
static const char __pyx_k_MFNType[] = "MFNType";
static const char __pyx_k_MatMode[] = "MatMode";
static const char __pyx_k_MatType[] = "MatType";
static const char __pyx_k_NEPConv[] = "NEPConv";
static const char __pyx_k_NEPStop[] = "NEPStop";
static const char __pyx_k_NEPType[] = "NEPType";
static const char __pyx_k_ONESIDE[] = "ONESIDE";
static const char __pyx_k_PARTIAL[] = "PARTIAL";
static const char __pyx_k_PEPConv[] = "PEPConv";
static const char __pyx_k_PEPStop[] = "PEPStop";
static const char __pyx_k_PEPType[] = "PEPType";
static const char __pyx_k_POLYGON[] = "POLYGON";
static const char __pyx_k_PRECOND[] = "PRECOND";
static const char __pyx_k_REFINED[] = "REFINED";
static const char __pyx_k_RG_type[] = "\n    RG type\n    ";
static const char __pyx_k_SINVERT[] = "SINVERT";
static const char __pyx_k_SVDConv[] = "SVDConv";
static const char __pyx_k_SVDStop[] = "SVDStop";
static const char __pyx_k_SVDType[] = "SVDType";
static const char __pyx_k_TWOSIDE[] = "TWOSIDE";
static const char __pyx_k_balance[] = "balance";
static const char __pyx_k_bv_type[] = "bv_type";
static const char __pyx_k_delayed[] = "delayed";
static const char __pyx_k_ds_type[] = "ds_type";
static const char __pyx_k_end_ang[] = "end_ang";
static const char __pyx_k_extract[] = "extract";
static const char __pyx_k_fn_type[] = "fn_type";
static const char __pyx_k_matname[] = "matname";
static const char __pyx_k_monitor[] = "monitor";
static const char __pyx_k_package[] = "package";
static const char __pyx_k_prepare[] = "__prepare__";
static const char __pyx_k_release[] = "release";
static const char __pyx_k_replace[] = "replace";
static const char __pyx_k_restart[] = "restart";
static const char __pyx_k_rg_type[] = "rg_type";
static const char __pyx_k_sfactor[] = "sfactor";
static const char __pyx_k_st_type[] = "st_type";
static const char __pyx_k_trueres[] = "trueres";
static const char __pyx_k_ABSOLUTE[] = "ABSOLUTE";
static const char __pyx_k_BACKWARD[] = "BACKWARD";
static const char __pyx_k_CONSTANT[] = "CONSTANT";
static const char __pyx_k_DIAGONAL[] = "DIAGONAL";
static const char __pyx_k_EPSWhich[] = "EPSWhich";
static const char __pyx_k_EXPLICIT[] = "EXPLICIT";
static const char __pyx_k_GIT_Date[] = "GIT Date:";
static const char __pyx_k_HARMONIC[] = "HARMONIC";
static const char __pyx_k_IFNEEDED[] = "IFNEEDED";
static const char __pyx_k_INTERPOL[] = "INTERPOL";
static const char __pyx_k_INTERVAL[] = "INTERVAL";
static const char __pyx_k_LAGUERRE[] = "LAGUERRE";
static const char __pyx_k_LEGENDRE[] = "LEGENDRE";
static const char __pyx_k_MONOMIAL[] = "MONOMIAL";
static const char __pyx_k_MULTIPLE[] = "MULTIPLE";
static const char __pyx_k_MULTIPLY[] = "MULTIPLY";
static const char __pyx_k_NARNOLDI[] = "NARNOLDI";
static const char __pyx_k_NEPWhich[] = "NEPWhich";
static const char __pyx_k_PEPBasis[] = "PEPBasis";
static const char __pyx_k_PEPScale[] = "PEPScale";
static const char __pyx_k_PEPWhich[] = "PEPWhich";
static const char __pyx_k_PERIODIC[] = "PERIODIC";
static const char __pyx_k_QARNOLDI[] = "QARNOLDI";
static const char __pyx_k_QuadRule[] = "QuadRule";
static const char __pyx_k_RATIONAL[] = "RATIONAL";
static const char __pyx_k_RAYLEIGH[] = "RAYLEIGH";
static const char __pyx_k_RELATIVE[] = "RELATIVE";
static const char __pyx_k_RESIDUAL[] = "RESIDUAL";
static const char __pyx_k_RealType[] = "RealType";
static const char __pyx_k_SMALLEST[] = "SMALLEST";
static const char __pyx_k_STANDARD[] = "STANDARD";
static const char __pyx_k_SUBSPACE[] = "SUBSPACE";
static const char __pyx_k_SVDWhich[] = "SVDWhich";
static const char __pyx_k_TSQRCHOL[] = "TSQRCHOL";
static const char __pyx_k_constant[] = "constant";
static const char __pyx_k_eps_type[] = "eps_type";
static const char __pyx_k_finalize[] = "_finalize";
static const char __pyx_k_function[] = "function";
static const char __pyx_k_getScale[] = "getScale";
static const char __pyx_k_getShift[] = "getShift";
static const char __pyx_k_getState[] = "getState";
static const char __pyx_k_globalup[] = "globalup";
static const char __pyx_k_jacobian[] = "jacobian";
static const char __pyx_k_mfn_type[] = "mfn_type";
static const char __pyx_k_nep_type[] = "nep_type";
static const char __pyx_k_pep_type[] = "pep_type";
static const char __pyx_k_qualname[] = "__qualname__";
static const char __pyx_k_realmats[] = "realmats";
static const char __pyx_k_reorthog[] = "reorthog";
static const char __pyx_k_setScale[] = "setScale";
static const char __pyx_k_setShift[] = "setShift";
static const char __pyx_k_setState[] = "setState";
static const char __pyx_k_stopping[] = "stopping";
static const char __pyx_k_subminor[] = "subminor";
static const char __pyx_k_svd_type[] = "svd_type";
static const char __pyx_k_trackall[] = "trackall";
static const char __pyx_k_twosided[] = "twosided";
static const char __pyx_k_vertical[] = "vertical";
static const char __pyx_k_BlockType[] = "BlockType";
static const char __pyx_k_CHEBYSHEV[] = "CHEBYSHEV";
static const char __pyx_k_COMM_NULL[] = "COMM_NULL";
static const char __pyx_k_COMM_SELF[] = "COMM_SELF";
static const char __pyx_k_CONDENSED[] = "CONDENSED";
static const char __pyx_k_DETERMINE[] = "DETERMINE";
static const char __pyx_k_DSMatType[] = "DSMatType";
static const char __pyx_k_ELEMENTAL[] = "ELEMENTAL";
static const char __pyx_k_ErrorType[] = "ErrorType";
static const char __pyx_k_HERMITIAN[] = "HERMITIAN";
static const char __pyx_k_ITERATING[] = "ITERATING";
static const char __pyx_k_NEPRefine[] = "NEPRefine";
static const char __pyx_k_PEPRefine[] = "PEPRefine";
static const char __pyx_k_REDUNDANT[] = "REDUNDANT";
static const char __pyx_k_SCALAPACK[] = "SCALAPACK";
static const char __pyx_k_SELECTIVE[] = "SELECTIVE";
static const char __pyx_k_STMatMode[] = "STMatMode";
static const char __pyx_k_StateType[] = "StateType";
static const char __pyx_k_TRLANCZOS[] = "TRLANCZOS";
static const char __pyx_k_TRUNCATED[] = "TRUNCATED";
static const char __pyx_k_TypeError[] = "TypeError";
static const char __pyx_k_WILKINSON[] = "WILKINSON";
static const char __pyx_k_arbitrary[] = "arbitrary";
static const char __pyx_k_doubleexp[] = "doubleexp";
static const char __pyx_k_duplicate[] = "duplicate";
static const char __pyx_k_fullbasis[] = "fullbasis";
static const char __pyx_k_getMethod[] = "getMethod";
static const char __pyx_k_getPurify[] = "getPurify";
static const char __pyx_k_getTarget[] = "getTarget";
static const char __pyx_k_metaclass[] = "__metaclass__";
static const char __pyx_k_norm_type[] = "norm_type";
static const char __pyx_k_operators[] = "operators";
static const char __pyx_k_setMethod[] = "setMethod";
static const char __pyx_k_setPurify[] = "setPurify";
static const char __pyx_k_setTarget[] = "setTarget";
static const char __pyx_k_spaceleft[] = "spaceleft";
static const char __pyx_k_start_ang[] = "start_ang";
static const char __pyx_k_structure[] = "structure";
static const char __pyx_k_CHEBYSHEV1[] = "CHEBYSHEV1";
static const char __pyx_k_CHEBYSHEV2[] = "CHEBYSHEV2";
static const char __pyx_k_COMM_WORLD[] = "COMM_WORLD";
static const char __pyx_k_CONTIGUOUS[] = "CONTIGUOUS";
static const char __pyx_k_EPSBalance[] = "EPSBalance";
static const char __pyx_k_Extraction[] = "Extraction";
static const char __pyx_k_GYROSCOPIC[] = "GYROSCOPIC";
static const char __pyx_k_HYPERBOLIC[] = "HYPERBOLIC";
static const char __pyx_k_ORTHOGONAL[] = "ORTHOGONAL";
static const char __pyx_k_OrthogType[] = "OrthogType";
static const char __pyx_k_PEPExtract[] = "PEPExtract";
static const char __pyx_k_RANDOMIZED[] = "RANDOMIZED";
static const char __pyx_k_RGQuadRule[] = "RGQuadRule";
static const char __pyx_k_RefineType[] = "RefineType";
static const char __pyx_k_STRUCTURED[] = "STRUCTURED";
static const char __pyx_k_ScalarType[] = "ScalarType";
static const char __pyx_k_ValueError[] = "ValueError";
static const char __pyx_k_authorinfo[] = "authorinfo";
static const char __pyx_k_comparison[] = "comparison";
static const char __pyx_k_createVecs[] = "createVecs";
static const char __pyx_k_extraction[] = "extraction";
static const char __pyx_k_getCompact[] = "getCompact";
static const char __pyx_k_getExtract[] = "getExtract";
static const char __pyx_k_getMatMode[] = "getMatMode";
static const char __pyx_k_getRefined[] = "getRefined";
static const char __pyx_k_getVersion[] = "getVersion";
static const char __pyx_k_initialize[] = "_initialize";
static const char __pyx_k_iterations[] = "iterations";
static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__";
static const char __pyx_k_setCompact[] = "setCompact";
static const char __pyx_k_setExtract[] = "setExtract";
static const char __pyx_k_setMatMode[] = "setMatMode";
static const char __pyx_k_setRefined[] = "setRefined";
static const char __pyx_k_spaceright[] = "spaceright";
static const char __pyx_k_BVSVDMethod[] = "BVSVDMethod";
static const char __pyx_k_CombineType[] = "CombineType";
static const char __pyx_k_ComplexType[] = "ComplexType";
static const char __pyx_k_DISTRIBUTED[] = "DISTRIBUTED";
static const char __pyx_k_DSStateType[] = "DSStateType";
static const char __pyx_k_GENERALIZED[] = "GENERALIZED";
static const char __pyx_k_KRYLOVSCHUR[] = "KRYLOVSCHUR";
static const char __pyx_k_MatMultType[] = "MatMultType";
static const char __pyx_k_MemoryError[] = "MemoryError";
static const char __pyx_k_ProblemType[] = "ProblemType";
static const char __pyx_k_TARGET_REAL[] = "TARGET_REAL";
static const char __pyx_k_TRAPEZOIDAL[] = "TRAPEZOIDAL";
static const char __pyx_k_createDense[] = "createDense";
static const char __pyx_k_getExtraRow[] = "getExtraRow";
static const char __pyx_k_getParallel[] = "getParallel";
static const char __pyx_k_getTrackAll[] = "getTrackAll";
static const char __pyx_k_getTwoSided[] = "getTwoSided";
static const char __pyx_k_initialsize[] = "initialsize";
static const char __pyx_k_isFinalized[] = "isFinalized";
static const char __pyx_k_krylovstart[] = "krylovstart";
static const char __pyx_k_setExtraRow[] = "setExtraRow";
static const char __pyx_k_setOperator[] = "setOperator";
static const char __pyx_k_setParallel[] = "setParallel";
static const char __pyx_k_setTrackAll[] = "setTrackAll";
static const char __pyx_k_setTwoSided[] = "setTwoSided";
static const char __pyx_k_BVOrthogType[] = "BVOrthogType";
static const char __pyx_k_CISSQuadRule[] = "CISSQuadRule";
static const char __pyx_k_DIVERGED_ITS[] = "DIVERGED_ITS";
static const char __pyx_k_EPSErrorType[] = "EPSErrorType";
static const char __pyx_k_INTERMEDIATE[] = "INTERMEDIATE";
static const char __pyx_k_JDProjection[] = "JDProjection";
static const char __pyx_k_LARGEST_REAL[] = "LARGEST_REAL";
static const char __pyx_k_NEPErrorType[] = "NEPErrorType";
static const char __pyx_k_PEPErrorType[] = "PEPErrorType";
static const char __pyx_k_ParallelType[] = "ParallelType";
static const char __pyx_k_RefineScheme[] = "RefineScheme";
static const char __pyx_k_SVDErrorType[] = "SVDErrorType";
static const char __pyx_k_SYNCHRONIZED[] = "SYNCHRONIZED";
static const char __pyx_k_getBlockSize[] = "getBlockSize";
static const char __pyx_k_getTransform[] = "getTransform";
static const char __pyx_k_problem_type[] = "problem_type";
static const char __pyx_k_setBlockSize[] = "setBlockSize";
static const char __pyx_k_setOperators[] = "setOperators";
static const char __pyx_k_setTransform[] = "setTransform";
static const char __pyx_k_BVMatMultType[] = "BVMatMultType";
static const char __pyx_k_CONVERGED_ITS[] = "CONVERGED_ITS";
static const char __pyx_k_CONVERGED_TOL[] = "CONVERGED_TOL";
static const char __pyx_k_EPSExtraction[] = "EPSExtraction";
static const char __pyx_k_FNCombineType[] = "FNCombineType";
static const char __pyx_k_SMALLEST_REAL[] = "SMALLEST_REAL";
static const char __pyx_k_getComplement[] = "getComplement";
static const char __pyx_k_getExtraction[] = "getExtraction";
static const char __pyx_k_getTolerances[] = "getTolerances";
static const char __pyx_k_isInitialized[] = "isInitialized";
static const char __pyx_k_setComplement[] = "setComplement";
static const char __pyx_k_setExtraction[] = "setExtraction";
static const char __pyx_k_setTolerances[] = "setTolerances";
static const char __pyx_k_CISSExtraction[] = "CISSExtraction";
static const char __pyx_k_CONVERGED_USER[] = "CONVERGED_USER";
static const char __pyx_k_DSParallelType[] = "DSParallelType";
static const char __pyx_k_EPSProblemType[] = "EPSProblemType";
static const char __pyx_k_FNParallelType[] = "FNParallelType";
static const char __pyx_k_HARMONIC_RIGHT[] = "HARMONIC_RIGHT";
static const char __pyx_k_NEPProblemType[] = "NEPProblemType";
static const char __pyx_k_PEPProblemType[] = "PEPProblemType";
static const char __pyx_k_PowerShiftType[] = "PowerShiftType";
static const char __pyx_k_SVDProblemType[] = "SVDProblemType";
static const char __pyx_k_getProblemType[] = "getProblemType";
static const char __pyx_k_getVersionInfo[] = "getVersionInfo";
static const char __pyx_k_petsc4py_PETSc[] = "petsc4py.PETSc";
static const char __pyx_k_setProblemType[] = "setProblemType";
static const char __pyx_k_slepc4py_SLEPc[] = "slepc4py.SLEPc";
static const char __pyx_k_CONVERGED_MAXIT[] = "CONVERGED_MAXIT";
static const char __pyx_k_ConvergedReason[] = "ConvergedReason";
static const char __pyx_k_EPSCISSQuadRule[] = "EPSCISSQuadRule";
static const char __pyx_k_NEPRefineScheme[] = "NEPRefineScheme";
static const char __pyx_k_OrthogBlockType[] = "OrthogBlockType";
static const char __pyx_k_PEPJDProjection[] = "PEPJDProjection";
static const char __pyx_k_PEPRefineScheme[] = "PEPRefineScheme";
static const char __pyx_k_SLEPc_SLEPc_pyx[] = "SLEPc/SLEPc.pyx";
static const char __pyx_k_getMatStructure[] = "getMatStructure";
static const char __pyx_k_getTrueResidual[] = "getTrueResidual";
static const char __pyx_k_setMatStructure[] = "setMatStructure";
static const char __pyx_k_setTrueResidual[] = "setTrueResidual";
static const char __pyx_k_HARMONIC_LARGEST[] = "HARMONIC_LARGEST";
static const char __pyx_k_OrthogRefineType[] = "OrthogRefineType";
static const char __pyx_k_REFINED_HARMONIC[] = "REFINED_HARMONIC";
static const char __pyx_k_TARGET_IMAGINARY[] = "TARGET_IMAGINARY";
static const char __pyx_k_TARGET_MAGNITUDE[] = "TARGET_MAGNITUDE";
static const char __pyx_k_TRLanczosGBidiag[] = "TRLanczosGBidiag";
static const char __pyx_k_getActiveColumns[] = "getActiveColumns";
static const char __pyx_k_getTransposeMode[] = "getTransposeMode";
static const char __pyx_k_setTransposeMode[] = "setTransposeMode";
static const char __pyx_k_BVOrthogBlockType[] = "BVOrthogBlockType";
static const char __pyx_k_EPSCISSExtraction[] = "EPSCISSExtraction";
static const char __pyx_k_EPSPowerShiftType[] = "EPSPowerShiftType";
static const char __pyx_k_HARMONIC_RELATIVE[] = "HARMONIC_RELATIVE";
static const char __pyx_k_LARGEST_IMAGINARY[] = "LARGEST_IMAGINARY";
static const char __pyx_k_LARGEST_MAGNITUDE[] = "LARGEST_MAGNITUDE";
static const char __pyx_k_NEPCISSExtraction[] = "NEPCISSExtraction";
static const char __pyx_k_PEPCISSExtraction[] = "PEPCISSExtraction";
static const char __pyx_k_BVOrthogRefineType[] = "BVOrthogRefineType";
static const char __pyx_k_DIVERGED_BREAKDOWN[] = "DIVERGED_BREAKDOWN";
static const char __pyx_k_EPSConvergedReason[] = "EPSConvergedReason";
static const char __pyx_k_MFNConvergedReason[] = "MFNConvergedReason";
static const char __pyx_k_NEPConvergedReason[] = "NEPConvergedReason";
static const char __pyx_k_PEPConvergedReason[] = "PEPConvergedReason";
static const char __pyx_k_SMALLEST_IMAGINARY[] = "SMALLEST_IMAGINARY";
static const char __pyx_k_SMALLEST_MAGNITUDE[] = "SMALLEST_MAGNITUDE";
static const char __pyx_k_SVDConvergedReason[] = "SVDConvergedReason";
static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
static const char __pyx_k_getWhichEigenpairs[] = "getWhichEigenpairs";
static const char __pyx_k_hasExternalPackage[] = "hasExternalPackage";
static const char __pyx_k_setWhichEigenpairs[] = "setWhichEigenpairs";
static const char __pyx_k_CONVERGED_ITERATING[] = "CONVERGED_ITERATING";
static const char __pyx_k_LanczosReorthogType[] = "LanczosReorthogType";
static const char __pyx_k_SVDTRLanczosGBidiag[] = "SVDTRLanczosGBidiag";
static const char __pyx_k_setOrthogonalization[] = "setOrthogonalization";
static const char __pyx_k_DIVERGED_LINEAR_SOLVE[] = "DIVERGED_LINEAR_SOLVE";
static const char __pyx_k_DIVERGED_SYMMETRY_LOST[] = "DIVERGED_SYMMETRY_LOST";
static const char __pyx_k_EPSLanczosReorthogType[] = "EPSLanczosReorthogType";
static const char __pyx_k_getWhichSingularTriplets[] = "getWhichSingularTriplets";
static const char __pyx_k_setWhichSingularTriplets[] = "setWhichSingularTriplets";
static const char __pyx_k_DIVERGED_SUBSPACE_EXHAUSTED[] = "DIVERGED_SUBSPACE_EXHAUSTED";
static const char __pyx_k_BV_mat_mult_types_VECS_Perform[] = "\n    BV mat-mult types\n\n    - `VECS`: Perform a matrix-vector multiply per each column.\n    - `MAT`:  Carry out a Mat-Mat product with a dense matrix.\n    ";
static const char __pyx_k_BV_orthogonalization_types_CGS[] = "\n    BV orthogonalization types\n\n    - `CGS`: Classical Gram-Schmidt.\n    - `MGS`: Modified Gram-Schmidt.\n    ";
static const char __pyx_k_EPS_problem_type_HEP_Hermitian[] = "\n    EPS problem type\n\n    - `HEP`:    Hermitian eigenproblem.\n    - `NHEP`:   Non-Hermitian eigenproblem.\n    - `GHEP`:   Generalized Hermitian eigenproblem.\n    - `GNHEP`:  Generalized Non-Hermitian eigenproblem.\n    - `PGNHEP`: Generalized Non-Hermitian eigenproblem\n                with positive definite ``B``.\n    - `GHIEP`:  Generalized Hermitian-indefinite eigenproblem.\n    ";
static const char __pyx_k_EPS_type_of_balancing_used_for[] = "\n    EPS type of balancing used for non-Hermitian problems\n\n    - `NONE`:     None.\n    - `ONESIDE`:  One-sided balancing.\n    - `TWOSIDE`:  Two-sided balancing.\n    - `USER`:     User-provided balancing matrices.\n    ";
static const char __pyx_k_RG_quadrature_rule_for_contour[] = "\n    RG quadrature rule for contour integral methods\n\n    - `TRAPEZOIDAL`: Trapezoidal rule.\n    - `CHEBYSHEV`:   Chebyshev points.\n    ";
static const char __pyx_k_BV_block_orthogonalization_type[] = "\n    BV block-orthogonalization types\n\n    - `GS`:       Gram-Schmidt.\n    - `CHOL`:     Cholesky.\n    - `TSQR`:     Tall-skinny QR.\n    - `TSQRCHOL`: Tall-skinny QR with Cholesky.\n    - `SVQB`:     SVQB.\n    ";
static const char __pyx_k_BV_methods_for_computing_the_SV[] = "\n    BV methods for computing the SVD\n\n    - `REFINE`: Based on the SVD of the cross product matrix S'*S, with refinement.\n    - `QR`:     Based on the SVD of the triangular factor of qr(S).\n    - `QR_CAA`: Variant of QR intended for use in cammunication-avoiding Arnoldi.\n    ";
static const char __pyx_k_BV_orthogonalization_refinement[] = "\n    BV orthogonalization refinement types\n\n    - `IFNEEDED`: Reorthogonalize if a criterion is satisfied.\n    - `NEVER`:    Never reorthogonalize.\n    - `ALWAYS`:   Always reorthogonalize.\n    ";
static const char __pyx_k_DS_parallel_types_REDUNDANT_Eve[] = "\n    DS parallel types\n\n    - `REDUNDANT`:    Every process performs the computation redundantly.\n    - `SYNCHRONIZED`: The first process sends the result to the rest.\n    - `DISTRIBUTED`:  Used in some cases to distribute the computation among processes.\n    ";
static const char __pyx_k_DS_state_types_RAW_Not_processe[] = "\n    DS state types\n\n    - `RAW`:          Not processed yet.\n    - `INTERMEDIATE`: Reduced to Hessenberg or tridiagonal form (or equivalent).\n    - `CONDENSED`:    Reduced to Schur or diagonal form (or equivalent).\n    - `TRUNCATED`:    Condensed form truncated to a smaller size.\n    ";
static const char __pyx_k_EPS_CISS_extraction_technique_R[] = "\n    EPS CISS extraction technique\n\n    - `RITZ`:   Ritz extraction.\n    - `HANKEL`: Extraction via Hankel eigenproblem.\n    ";
static const char __pyx_k_EPS_CISS_quadrature_rule_TRAPEZ[] = "\n    EPS CISS quadrature rule\n\n    - `TRAPEZOIDAL`: Trapezoidal rule.\n    - `CHEBYSHEV`:   Chebyshev points.\n    ";
static const char __pyx_k_EPS_Lanczos_reorthogonalization[] = "\n    EPS Lanczos reorthogonalization type\n\n    - `LOCAL`:     Local reorthogonalization only.\n    - `FULL`:      Full reorthogonalization.\n    - `SELECTIVE`: Selective reorthogonalization.\n    - `PERIODIC`:  Periodic reorthogonalization.\n    - `PARTIAL`:   Partial reorthogonalization.\n    - `DELAYED`:   Delayed reorthogonalization.\n    ";
static const char __pyx_k_EPS_Power_shift_type_CONSTANT_C[] = "\n    EPS Power shift type.\n\n    - `CONSTANT`:  Constant shift.\n    - `RAYLEIGH`:  Rayleigh quotient.\n    - `WILKINSON`: Wilkinson shift.\n    ";
static const char __pyx_k_EPS_convergence_reasons_CONVERG[] = "\n    EPS convergence reasons\n\n    - `CONVERGED_TOL`:          All eigenpairs converged to requested tolerance.\n    - `CONVERGED_USER`:         User-defined convergence criterion satisfied.\n    - `DIVERGED_ITS`:           Maximum number of iterations exceeded.\n    - `DIVERGED_BREAKDOWN`:     Solver failed due to breakdown.\n    - `DIVERGED_SYMMETRY_LOST`: Lanczos-type method could not preserve symmetry.\n    - `CONVERGED_ITERATING`:    Iteration not finished yet.\n    ";
static const char __pyx_k_EPS_convergence_test_ABS_Absolu[] = "\n    EPS convergence test\n\n    - `ABS`:  Absolute convergence test.\n    - `REL`:  Convergence test relative to the eigenvalue.\n    - `NORM`: Convergence test relative to the matrix norms.\n    - `USER`: User-defined convergence test.\n    ";
static const char __pyx_k_EPS_desired_part_of_spectrum_LA[] = "\n    EPS desired part of spectrum\n\n    - `LARGEST_MAGNITUDE`:  Largest magnitude (default).\n    - `SMALLEST_MAGNITUDE`: Smallest magnitude.\n    - `LARGEST_REAL`:       Largest real parts.\n    - `SMALLEST_REAL`:      Smallest real parts.\n    - `LARGEST_IMAGINARY`:  Largest imaginary parts in magnitude.\n    - `SMALLEST_IMAGINARY`: Smallest imaginary parts in magnitude.\n    - `TARGET_MAGNITUDE`:   Closest to target (in magnitude).\n    - `TARGET_REAL`:        Real part closest to target.\n    - `TARGET_IMAGINARY`:   Imaginary part closest to target.\n    - `ALL`:                All eigenvalues in an interval.\n    - `USER`:               User defined selection.\n    ";
static const char __pyx_k_EPS_error_type_to_assess_accura[] = "\n    EPS error type to assess accuracy of computed solutions\n\n    - `ABSOLUTE`: Absolute error.\n    - `RELATIVE`: Relative error.\n    - `BACKWARD`: Backward error.\n    ";
static const char __pyx_k_EPS_extraction_technique_RITZ_S[] = "\n    EPS extraction technique\n\n    - `RITZ`:              Standard Rayleigh-Ritz extraction.\n    - `HARMONIC`:          Harmonic extraction.\n    - `HARMONIC_RELATIVE`: Harmonic extraction relative to the eigenvalue.\n    - `HARMONIC_RIGHT`:    Harmonic extraction for rightmost eigenvalues.\n    - `HARMONIC_LARGEST`:  Harmonic extraction for largest magnitude (without target).\n    - `REFINED`:           Refined extraction.\n    - `REFINED_HARMONIC`:  Refined harmonic extraction.\n    ";
static const char __pyx_k_EPS_stopping_test_BASIC_Default[] = "\n    EPS stopping test\n\n    - `BASIC`: Default stopping test.\n    - `USER`:  User-defined stopping test.\n    ";
static const char __pyx_k_EPS_type_Native_sparse_eigensol[] = "\n    EPS type\n\n    Native sparse eigensolvers.\n\n    - `POWER`:        Power Iteration, Inverse Iteration, RQI.\n    - `SUBSPACE`:     Subspace Iteration.\n    - `ARNOLDI`:      Arnoldi.\n    - `LANCZOS`:      Lanczos.\n    - `KRYLOVSCHUR`:  Krylov-Schur (default).\n    - `GD`:           Generalized Davidson.\n    - `JD`:           Jacobi-Davidson.\n    - `RQCG`:         Rayleigh Quotient Conjugate Gradient.\n    - `LOBPCG`:       Locally Optimal Block Preconditioned Conjugate Gradient.\n    - `CISS`:         Contour Integral Spectrum Slicing.\n    - `LYAPII`:       Lyapunov inverse iteration.\n    - `LAPACK`:       Wrappers to dense eigensolvers in Lapack.\n\n    Wrappers to external eigensolvers\n    (should be enabled during installation of SLEPc)\n\n    - `ARPACK`:\n    - `TRLAN`:\n    - `BLOPEX`:\n    - `PRIMME`:\n    - `FEAST`:\n    - `SCALAPACK`:\n    - `ELPA`:\n    - `ELEMENTAL`:\n    - `EVSL`:\n    ";
static const char __pyx_k_FN_parallel_types_REDUNDANT_Eve[] = "\n    FN parallel types\n\n    - `REDUNDANT`:    Every process performs the computation redundantly.\n    - `SYNCHRONIZED`: The first process sends the result to the rest.\n    ";
static const char __pyx_k_FN_type_of_combination_of_child[] = "\n    FN type of combination of child functions\n\n    - `ADD`:       Addition         f(x) = f1(x)+f2(x)\n    - `MULTIPLY`:  Multiplication   f(x) = f1(x)*f2(x)\n    - `DIVIDE`:    Division         f(x) = f1(x)/f2(x)\n    - `COMPOSE`:   Composition      f(x) = f2(f1(x))\n    ";
static const char __pyx_k_MFN_type_Action_of_a_matrix_fun[] = "\n    MFN type\n\n    Action of a matrix function on a vector.\n\n    - `KRYLOV`:  Restarted Krylov solver.\n    - `EXPOKIT`: Implementation of the method in Expokit.\n    ";
static const char __pyx_k_NEP_CISS_extraction_technique_R[] = "\n    NEP CISS extraction technique\n\n    - `RITZ`:   Ritz extraction.\n    - `HANKEL`: Extraction via Hankel eigenproblem.\n    - `CAA`:    Communication-avoiding Arnoldi.\n    ";
static const char __pyx_k_NEP_convergence_reasons_CONVERG[] = "\n    NEP convergence reasons\n\n    - `CONVERGED_TOL`:               All eigenpairs converged to requested tolerance.\n    - `CONVERGED_USER`:              User-defined convergence criterion satisfied.\n    - `DIVERGED_ITS`:                Maximum number of iterations exceeded.\n    - `DIVERGED_BREAKDOWN`:          Solver failed due to breakdown.\n    - `DIVERGED_LINEAR_SOLVE`:       Inner linear solve failed.\n    - `DIVERGED_SUBSPACE_EXHAUSTED`: Run out of space for the basis in an unrestarted solver.\n    - `CONVERGED_ITERATING`:         Iteration not finished yet.\n    ";
static const char __pyx_k_NEP_convergence_test_ABS_Absolu[] = "\n    NEP convergence test\n\n    - `ABS`:  Absolute convergence test.\n    - `REL`:  Convergence test relative to the eigenvalue.\n    - `NORM`: Convergence test relative to the matrix norms.\n    - `USER`: User-defined convergence test.\n    ";
static const char __pyx_k_NEP_desired_part_of_spectrum_LA[] = "\n    NEP desired part of spectrum\n\n    - `LARGEST_MAGNITUDE`:  Largest magnitude (default).\n    - `SMALLEST_MAGNITUDE`: Smallest magnitude.\n    - `LARGEST_REAL`:       Largest real parts.\n    - `SMALLEST_REAL`:      Smallest real parts.\n    - `LARGEST_IMAGINARY`:  Largest imaginary parts in magnitude.\n    - `SMALLEST_IMAGINARY`: Smallest imaginary parts in magnitude.\n    - `TARGET_MAGNITUDE`:   Closest to target (in magnitude).\n    - `TARGET_REAL`:        Real part closest to target.\n    - `TARGET_IMAGINARY`:   Imaginary part closest to target.\n    - `ALL`:                All eigenvalues in a region.\n    - `USER`:               User defined selection.\n    ";
static const char __pyx_k_NEP_error_type_to_assess_accura[] = "\n    NEP error type to assess accuracy of computed solutions\n\n    - `ABSOLUTE`: Absolute error.\n    - `RELATIVE`: Relative error.\n    - `BACKWARD`: Backward error.\n    ";
static const char __pyx_k_NEP_problem_type_GENERAL_Genera[] = "\n    NEP problem type\n\n    - `GENERAL`:  General nonlinear eigenproblem.\n    - `RATIONAL`: NEP defined in split form with all f_i rational.\n    ";
static const char __pyx_k_NEP_refinement_strategy_NONE_No[] = "\n    NEP refinement strategy\n\n    - `NONE`:     No refinement.\n    - `SIMPLE`:   Refine eigenpairs one by one.\n    - `MULTIPLE`: Refine all eigenpairs simultaneously (invariant pair).\n    ";
static const char __pyx_k_NEP_scheme_for_solving_linear_s[] = "\n    NEP scheme for solving linear systems during iterative refinement\n\n    - `SCHUR`:    Schur complement.\n    - `MBE`:      Mixed block elimination.\n    - `EXPLICIT`: Build the explicit matrix.\n    ";
static const char __pyx_k_NEP_stopping_test_BASIC_Default[] = "\n    NEP stopping test\n\n    - `BASIC`: Default stopping test.\n    - `USER`:  User-defined stopping test.\n    ";
static const char __pyx_k_NEP_type_Nonlinear_eigensolvers[] = "\n    NEP type\n\n    Nonlinear eigensolvers.\n\n    - `RII`:      Residual inverse iteration.\n    - `SLP`:      Successive linear problems.\n    - `NARNOLDI`: Nonlinear Arnoldi.\n    - `CISS`:     Contour integral spectrum slice.\n    - `INTERPOL`: Polynomial interpolation.\n    - `NLEIGS`:   Fully rational Krylov method for nonlinear eigenproblems.\n    ";
static const char __pyx_k_PEP_CISS_extraction_technique_R[] = "\n    PEP CISS extraction technique\n\n    - `RITZ`:   Ritz extraction.\n    - `HANKEL`: Extraction via Hankel eigenproblem.\n    - `CAA`:    Communication-avoiding Arnoldi.\n    ";
static const char __pyx_k_PEP_basis_type_for_the_represen[] = "\n    PEP basis type for the representation of the polynomial\n\n    - `MONOMIAL`:   Monomials (default).\n    - `CHEBYSHEV1`: Chebyshev polynomials of the 1st kind.\n    - `CHEBYSHEV2`: Chebyshev polynomials of the 2nd kind.\n    - `LEGENDRE`:   Legendre polynomials.\n    - `LAGUERRE`:   Laguerre polynomials.\n    - `HERMITE`:    Hermite polynomials.\n    ";
static const char __pyx_k_PEP_convergence_reasons_CONVERG[] = "\n    PEP convergence reasons\n\n    - `CONVERGED_TOL`:          All eigenpairs converged to requested tolerance.\n    - `CONVERGED_USER`:         User-defined convergence criterion satisfied.\n    - `DIVERGED_ITS`:           Maximum number of iterations exceeded.\n    - `DIVERGED_BREAKDOWN`:     Solver failed due to breakdown.\n    - `DIVERGED_SYMMETRY_LOST`: Lanczos-type method could not preserve symmetry.\n    - `CONVERGED_ITERATING`:    Iteration not finished yet.\n    ";
static const char __pyx_k_PEP_convergence_test_ABS_Absolu[] = "\n    PEP convergence test\n\n    - `ABS`:  Absolute convergence test.\n    - `REL`:  Convergence test relative to the eigenvalue.\n    - `NORM`: Convergence test relative to the matrix norms.\n    - `USER`: User-defined convergence test.\n    ";
static const char __pyx_k_PEP_desired_part_of_spectrum_LA[] = "\n    PEP desired part of spectrum\n\n    - `LARGEST_MAGNITUDE`:  Largest magnitude (default).\n    - `SMALLEST_MAGNITUDE`: Smallest magnitude.\n    - `LARGEST_REAL`:       Largest real parts.\n    - `SMALLEST_REAL`:      Smallest real parts.\n    - `LARGEST_IMAGINARY`:  Largest imaginary parts in magnitude.\n    - `SMALLEST_IMAGINARY`: Smallest imaginary parts in magnitude.\n    - `TARGET_MAGNITUDE`:   Closest to target (in magnitude).\n    - `TARGET_REAL`:        Real part closest to target.\n    - `TARGET_IMAGINARY`:   Imaginary part closest to target.\n    - `ALL`:                All eigenvalues in an interval.\n    - `USER`:               User-defined criterion.\n    ";
static const char __pyx_k_PEP_error_type_to_assess_accura[] = "\n    PEP error type to assess accuracy of computed solutions\n\n    - `ABSOLUTE`: Absolute error.\n    - `RELATIVE`: Relative error.\n    - `BACKWARD`: Backward error.\n    ";
static const char __pyx_k_PEP_extraction_strategy_used_to[] = "\n    PEP extraction strategy used to obtain eigenvectors of the PEP from the\n    eigenvectors of the linearization\n\n    - `NONE`:       Use the first block.\n    - `NORM`:       Use the first or last block depending on norm of H.\n    - `RESIDUAL`:   Use the block with smallest residual.\n    - `STRUCTURED`: Combine all blocks in a certain way.\n    ";
static const char __pyx_k_PEP_problem_type_GENERAL_No_str[] = "\n    PEP problem type\n\n    - `GENERAL`:    No structure.\n    - `HERMITIAN`:  Hermitian structure.\n    - `HYPERBOLIC`: QEP with Hermitian matrices, M>0, (x'Cx)^2 > 4(x'Mx)(x'Kx).\n    - `GYROSCOPIC`: QEP with M, K  Hermitian, M>0, C skew-Hermitian.\n    ";
static const char __pyx_k_PEP_refinement_strategy_NONE_No[] = "\n    PEP refinement strategy\n\n    - `NONE`:     No refinement.\n    - `SIMPLE`:   Refine eigenpairs one by one.\n    - `MULTIPLE`: Refine all eigenpairs simultaneously (invariant pair).\n    ";
static const char __pyx_k_PEP_scaling_strategy_NONE_No_sc[] = "\n    PEP scaling strategy\n\n    - `NONE`:     No scaling.\n    - `SCALAR`:   Parameter scaling.\n    - `DIAGONAL`: Diagonal scaling.\n    - `BOTH`:     Both parameter and diagonal scaling.\n    ";
static const char __pyx_k_PEP_scheme_for_solving_linear_s[] = "\n    PEP scheme for solving linear systems during iterative refinement\n\n    - `SCHUR`:    Schur complement.\n    - `MBE`:      Mixed block elimination.\n    - `EXPLICIT`: Build the explicit matrix.\n    ";
static const char __pyx_k_PEP_stopping_test_BASIC_Default[] = "\n    PEP stopping test\n\n    - `BASIC`: Default stopping test.\n    - `USER`:  User-defined stopping test.\n    ";
static const char __pyx_k_PEP_type_Polynomial_eigensolver[] = "\n    PEP type\n\n    Polynomial eigensolvers.\n\n    - `LINEAR`:   Linearization via EPS.\n    - `QARNOLDI`: Q-Arnoldi for quadratic problems.\n    - `TOAR`:     Two-level orthogonal Arnoldi.\n    - `STOAR`:    Symmetric TOAR.\n    - `JD`:       Polynomial Jacobi-Davidson.\n    - `CISS`:     Contour integral spectrum slice.\n    ";
static const char __pyx_k_PEP_type_of_projection_to_be_us[] = "\n    PEP type of projection to be used in the Jacobi-Davidson solver\n\n    - `HARMONIC`:   Harmonic projection.\n    - `ORTHOGONAL`: Orthogonal projection.\n    ";
static const char __pyx_k_ST_matrix_mode_COPY_A_working_c[] = "\n    ST matrix mode\n\n    - `COPY`:    A working copy of the matrix is created.\n    - `INPLACE`: The operation is computed in-place.\n    - `SHELL`:   The matrix ``A-sigma*B`` is handled as an\n      implicit matrix.\n    ";
static const char __pyx_k_ST_types_SHELL_User_defined_SHI[] = "\n    ST types\n\n    - `SHELL`:   User-defined.\n    - `SHIFT`:   Shift from origin.\n    - `SINVERT`: Shift-and-invert.\n    - `CAYLEY`:  Cayley transform.\n    - `PRECOND`: Preconditioner.\n    - `FILTER`:  Polynomial filter.\n    ";
static const char __pyx_k_SVD_TRLanczos_bidiagonalization[] = "\n    SVD TRLanczos bidiagonalization choices for the GSVD case\n\n    - `SINGLE`: Single bidiagonalization (Qa).\n    - `UPPER`:  Joint bidiagonalization, both Qa and Qb in upper bidiagonal form.\n    - `LOWER`:  Joint bidiagonalization, Qa lower bidiagonal, Qb upper bidiagonal.\n    ";
static const char __pyx_k_SVD_convergence_reasons_CONVERG[] = "\n    SVD convergence reasons\n\n    - `CONVERGED_TOL`:       All eigenpairs converged to requested tolerance.\n    - `CONVERGED_USER`:      User-defined convergence criterion satisfied.\n    - `CONVERGED_MAXIT`:     Maximum iterations completed in case MAXIT convergence criterion.\n    - `DIVERGED_ITS`:        Maximum number of iterations exceeded.\n    - `DIVERGED_BREAKDOWN`:  Solver failed due to breakdown.\n    - `CONVERGED_ITERATING`: Iteration not finished yet.\n    ";
static const char __pyx_k_SVD_convergence_test_ABS_Absolu[] = "\n    SVD convergence test\n\n    - `ABS`:   Absolute convergence test.\n    - `REL`:   Convergence test relative to the singular value.\n    - `NORM`:  Convergence test relative to the matrix norms.\n    - `MAXIT`: No convergence until maximum number of iterations has been reached.\n    - `USER`:  User-defined convergence test.\n    ";
static const char __pyx_k_SVD_desired_part_of_spectrum_LA[] = "\n    SVD desired part of spectrum\n\n    - `LARGEST`:  Largest singular values.\n    - `SMALLEST`: Smallest singular values.\n    ";
static const char __pyx_k_SVD_error_type_to_assess_accura[] = "\n    SVD error type to assess accuracy of computed solutions\n\n    - `ABSOLUTE`: Absolute error.\n    - `RELATIVE`: Relative error.\n    - `NORM`:     Error relative to the matrix norm.\n    ";
static const char __pyx_k_SVD_problem_type_STANDARD_Stand[] = "\n    SVD problem type\n\n    - `STANDARD`:    Standard SVD.\n    - `GENERALIZED`: Generalized singular value decomposition (GSVD).\n    - `HYPERBOLIC` : Hyperbolic singular value decomposition (HSVD).\n    ";
static const char __pyx_k_SVD_stopping_test_BASIC_Default[] = "\n    SVD stopping test\n\n    - `BASIC`: Default stopping test.\n    - `USER`:  User-defined stopping test.\n    ";
static const char __pyx_k_SVD_types_CROSS_Eigenproblem_wi[] = "\n    SVD types\n\n    - `CROSS`:      Eigenproblem with the cross-product matrix.\n    - `CYCLIC`:     Eigenproblem with the cyclic matrix.\n    - `LAPACK`:     Wrappers to dense SVD solvers in Lapack.\n    - `LANCZOS`:    Lanczos.\n    - `TRLANCZOS`:  Thick-restart Lanczos.\n    - `RANDOMIZED`: Iterative RSVD for low-rank matrices.\n\n    Wrappers to external SVD solvers\n    (should be enabled during installation of SLEPc)\n\n    - `SCALAPACK`:\n    - `ELEMENTAL`:\n    - `PRIMME`:\n    ";
static const char __pyx_k_Scalable_Library_for_Eigenvalue[] = "\nScalable Library for Eigenvalue Problem Computations\n";
static const char __pyx_k_To_refer_to_one_of_the_matrices[] = "\n    To refer to one of the matrices stored internally in DS\n\n    - `A`:  first matrix of eigenproblem/singular value problem.\n    - `B`:  second matrix of a generalized eigenproblem.\n    - `C`:  third matrix of a quadratic eigenproblem.\n    - `T`:  tridiagonal matrix.\n    - `D`:  diagonal matrix.\n    - `Q`:  orthogonal matrix of (right) Schur vectors.\n    - `Z`:  orthogonal matrix of left Schur vectors.\n    - `X`:  right eigenvectors.\n    - `Y`:  left eigenvectors.\n    - `U`:  left singular vectors.\n    - `V`:  right singular vectors.\n    - `W`:  workspace matrix.\n    ";
static const char __pyx_k_local_and_global_sizes_cannot_be[] = "local and global sizes cannot be both 'DECIDE'";
static PyObject *__pyx_n_s_A;
static PyObject *__pyx_n_s_ABS;
static PyObject *__pyx_n_s_ABSOLUTE;
static PyObject *__pyx_n_s_ADD;
static PyObject *__pyx_n_s_ALL;
static PyObject *__pyx_n_s_ALWAYS;
static PyObject *__pyx_n_s_ARNOLDI;
static PyObject *__pyx_n_s_ARPACK;
static PyObject *__pyx_n_s_Au;
static PyObject *__pyx_n_s_B;
static PyObject *__pyx_n_s_BACKWARD;
static PyObject *__pyx_n_s_BASIC;
static PyObject *__pyx_n_s_BLOPEX;
static PyObject *__pyx_n_s_BOTH;
static PyObject *__pyx_n_s_BV;
static PyObject *__pyx_n_s_BVMatMultType;
static PyObject *__pyx_n_s_BVOrthogBlockType;
static PyObject *__pyx_n_s_BVOrthogRefineType;
static PyObject *__pyx_n_s_BVOrthogType;
static PyObject *__pyx_n_s_BVSVDMethod;
static PyObject *__pyx_n_s_BVType;
static PyObject *__pyx_kp_s_BV_block_orthogonalization_type;
static PyObject *__pyx_kp_s_BV_mat_mult_types_VECS_Perform;
static PyObject *__pyx_kp_s_BV_methods_for_computing_the_SV;
static PyObject *__pyx_kp_s_BV_orthogonalization_refinement;
static PyObject *__pyx_kp_s_BV_orthogonalization_types_CGS;
static PyObject *__pyx_kp_s_BV_type;
static PyObject *__pyx_n_s_Balance;
static PyObject *__pyx_n_s_Basis;
static PyObject *__pyx_n_s_BlockType;
static PyObject *__pyx_n_s_Bu;
static PyObject *__pyx_n_s_C;
static PyObject *__pyx_n_s_CAA;
static PyObject *__pyx_n_s_CAYLEY;
static PyObject *__pyx_n_s_CGS;
static PyObject *__pyx_n_s_CHEBYSHEV;
static PyObject *__pyx_n_s_CHEBYSHEV1;
static PyObject *__pyx_n_s_CHEBYSHEV2;
static PyObject *__pyx_n_s_CHOL;
static PyObject *__pyx_n_s_CISS;
static PyObject *__pyx_n_s_CISSExtraction;
static PyObject *__pyx_n_s_CISSQuadRule;
static PyObject *__pyx_n_s_COMBINE;
static PyObject *__pyx_n_s_COMM_NULL;
static PyObject *__pyx_n_s_COMM_SELF;
static PyObject *__pyx_n_s_COMM_WORLD;
static PyObject *__pyx_n_s_COMPOSE;
static PyObject *__pyx_n_s_CONDENSED;
static PyObject *__pyx_n_s_CONSTANT;
static PyObject *__pyx_n_s_CONTIGUOUS;
static PyObject *__pyx_n_s_CONVERGED_ITERATING;
static PyObject *__pyx_n_s_CONVERGED_ITS;
static PyObject *__pyx_n_s_CONVERGED_MAXIT;
static PyObject *__pyx_n_s_CONVERGED_TOL;
static PyObject *__pyx_n_s_CONVERGED_USER;
static PyObject *__pyx_n_s_COPY;
static PyObject *__pyx_n_s_CROSS;
static PyObject *__pyx_n_s_CYCLIC;
static PyObject *__pyx_n_s_CombineType;
static PyObject *__pyx_n_s_ComplexType;
static PyObject *__pyx_n_s_Conv;
static PyObject *__pyx_n_s_ConvergedReason;
static PyObject *__pyx_n_s_D;
static PyObject *__pyx_n_s_DECIDE;
static PyObject *__pyx_n_s_DEFAULT;
static PyObject *__pyx_n_s_DELAYED;
static PyObject *__pyx_n_s_DETERMINE;
static PyObject *__pyx_n_s_DIAGONAL;
static PyObject *__pyx_n_s_DISTRIBUTED;
static PyObject *__pyx_n_s_DIVERGED_BREAKDOWN;
static PyObject *__pyx_n_s_DIVERGED_ITS;
static PyObject *__pyx_n_s_DIVERGED_LINEAR_SOLVE;
static PyObject *__pyx_n_s_DIVERGED_SUBSPACE_EXHAUSTED;
static PyObject *__pyx_n_s_DIVERGED_SYMMETRY_LOST;
static PyObject *__pyx_n_s_DIVIDE;
static PyObject *__pyx_n_s_DS;
static PyObject *__pyx_n_s_DSMatType;
static PyObject *__pyx_n_s_DSParallelType;
static PyObject *__pyx_n_s_DSStateType;
static PyObject *__pyx_n_s_DSType;
static PyObject *__pyx_kp_s_DS_parallel_types_REDUNDANT_Eve;
static PyObject *__pyx_kp_s_DS_state_types_RAW_Not_processe;
static PyObject *__pyx_kp_s_DS_type;
static PyObject *__pyx_n_s_Dl;
static PyObject *__pyx_n_s_Dr;
static PyObject *__pyx_n_s_ELEMENTAL;
static PyObject *__pyx_n_s_ELLIPSE;
static PyObject *__pyx_n_s_ELPA;
static PyObject *__pyx_n_s_EPS;
static PyObject *__pyx_n_s_EPSBalance;
static PyObject *__pyx_n_s_EPSCISSExtraction;
static PyObject *__pyx_n_s_EPSCISSQuadRule;
static PyObject *__pyx_n_s_EPSConv;
static PyObject *__pyx_n_s_EPSConvergedReason;
static PyObject *__pyx_n_s_EPSErrorType;
static PyObject *__pyx_n_s_EPSExtraction;
static PyObject *__pyx_n_s_EPSLanczosReorthogType;
static PyObject *__pyx_n_s_EPSPowerShiftType;
static PyObject *__pyx_n_s_EPSProblemType;
static PyObject *__pyx_n_s_EPSStop;
static PyObject *__pyx_n_s_EPSType;
static PyObject *__pyx_n_s_EPSWhich;
static PyObject *__pyx_kp_s_EPS_CISS_extraction_technique_R;
static PyObject *__pyx_kp_s_EPS_CISS_quadrature_rule_TRAPEZ;
static PyObject *__pyx_kp_s_EPS_Lanczos_reorthogonalization;
static PyObject *__pyx_kp_s_EPS_Power_shift_type_CONSTANT_C;
static PyObject *__pyx_kp_s_EPS_convergence_reasons_CONVERG;
static PyObject *__pyx_kp_s_EPS_convergence_test_ABS_Absolu;
static PyObject *__pyx_kp_s_EPS_desired_part_of_spectrum_LA;
static PyObject *__pyx_kp_s_EPS_error_type_to_assess_accura;
static PyObject *__pyx_kp_s_EPS_extraction_technique_RITZ_S;
static PyObject *__pyx_kp_s_EPS_problem_type_HEP_Hermitian;
static PyObject *__pyx_kp_s_EPS_stopping_test_BASIC_Default;
static PyObject *__pyx_kp_s_EPS_type_Native_sparse_eigensol;
static PyObject *__pyx_kp_s_EPS_type_of_balancing_used_for;
static PyObject *__pyx_n_s_EVSL;
static PyObject *__pyx_n_s_EXP;
static PyObject *__pyx_n_s_EXPLICIT;
static PyObject *__pyx_n_s_EXPOKIT;
static PyObject *__pyx_n_s_Error;
static PyObject *__pyx_n_s_ErrorType;
static PyObject *__pyx_n_s_Extract;
static PyObject *__pyx_n_s_Extraction;
static PyObject *__pyx_n_s_F;
static PyObject *__pyx_n_s_FEAST;
static PyObject *__pyx_n_s_FILTER;
static PyObject *__pyx_n_s_FN;
static PyObject *__pyx_n_s_FNCombineType;
static PyObject *__pyx_n_s_FNParallelType;
static PyObject *__pyx_n_s_FNType;
static PyObject *__pyx_kp_s_FN_parallel_types_REDUNDANT_Eve;
static PyObject *__pyx_kp_s_FN_type;
static PyObject *__pyx_kp_s_FN_type_of_combination_of_child;
static PyObject *__pyx_n_s_FULL;
static PyObject *__pyx_n_s_GD;
static PyObject *__pyx_n_s_GENERAL;
static PyObject *__pyx_n_s_GENERALIZED;
static PyObject *__pyx_n_s_GHEP;
static PyObject *__pyx_n_s_GHIEP;
static PyObject *__pyx_kp_s_GIT_Date;
static PyObject *__pyx_n_s_GNHEP;
static PyObject *__pyx_n_s_GS;
static PyObject *__pyx_n_s_GSVD;
static PyObject *__pyx_n_s_GYROSCOPIC;
static PyObject *__pyx_n_s_HANKEL;
static PyObject *__pyx_n_s_HARMONIC;
static PyObject *__pyx_n_s_HARMONIC_LARGEST;
static PyObject *__pyx_n_s_HARMONIC_RELATIVE;
static PyObject *__pyx_n_s_HARMONIC_RIGHT;
static PyObject *__pyx_n_s_HEP;
static PyObject *__pyx_n_s_HERMITE;
static PyObject *__pyx_n_s_HERMITIAN;
static PyObject *__pyx_n_s_HYPERBOLIC;
static PyObject *__pyx_n_s_IFNEEDED;
static PyObject *__pyx_n_s_INPLACE;
static PyObject *__pyx_n_s_INTERMEDIATE;
static PyObject *__pyx_n_s_INTERPOL;
static PyObject *__pyx_n_s_INTERVAL;
static PyObject *__pyx_n_s_INVSQRT;
static PyObject *__pyx_n_s_ITERATING;
static PyObject *__pyx_n_s_IntType;
static PyObject *__pyx_n_s_J;
static PyObject *__pyx_n_s_JD;
static PyObject *__pyx_n_s_JDProjection;
static PyObject *__pyx_n_s_KRYLOV;
static PyObject *__pyx_n_s_KRYLOVSCHUR;
static PyObject *__pyx_n_s_LAGUERRE;
static PyObject *__pyx_n_s_LANCZOS;
static PyObject *__pyx_n_s_LAPACK;
static PyObject *__pyx_n_s_LARGEST;
static PyObject *__pyx_n_s_LARGEST_IMAGINARY;
static PyObject *__pyx_n_s_LARGEST_MAGNITUDE;
static PyObject *__pyx_n_s_LARGEST_REAL;
static PyObject *__pyx_n_s_LEGENDRE;
static PyObject *__pyx_n_s_LINEAR;
static PyObject *__pyx_n_s_LOBPCG;
static PyObject *__pyx_n_s_LOCAL;
static PyObject *__pyx_n_s_LOG;
static PyObject *__pyx_n_s_LOWER;
static PyObject *__pyx_n_s_LYAPII;
static PyObject *__pyx_n_s_LanczosReorthogType;
static PyObject *__pyx_n_s_MAT;
static PyObject *__pyx_n_s_MAXIT;
static PyObject *__pyx_n_s_MBE;
static PyObject *__pyx_n_s_MFN;
static PyObject *__pyx_n_s_MFNConvergedReason;
static PyObject *__pyx_n_s_MFNType;
static PyObject *__pyx_kp_s_MFN_type_Action_of_a_matrix_fun;
static PyObject *__pyx_n_s_MGS;
static PyObject *__pyx_n_s_MONOMIAL;
static PyObject *__pyx_n_s_MULTIPLE;
static PyObject *__pyx_n_s_MULTIPLY;
static PyObject *__pyx_n_s_MatMode;
static PyObject *__pyx_n_s_MatMultType;
static PyObject *__pyx_n_s_MatType;
static PyObject *__pyx_n_s_MemoryError;
static PyObject *__pyx_n_s_NARNOLDI;
static PyObject *__pyx_n_s_NEP;
static PyObject *__pyx_n_s_NEPCISSExtraction;
static PyObject *__pyx_n_s_NEPConv;
static PyObject *__pyx_n_s_NEPConvergedReason;
static PyObject *__pyx_n_s_NEPErrorType;
static PyObject *__pyx_n_s_NEPProblemType;
static PyObject *__pyx_n_s_NEPRefine;
static PyObject *__pyx_n_s_NEPRefineScheme;
static PyObject *__pyx_n_s_NEPStop;
static PyObject *__pyx_n_s_NEPType;
static PyObject *__pyx_n_s_NEPWhich;
static PyObject *__pyx_kp_s_NEP_CISS_extraction_technique_R;
static PyObject *__pyx_kp_s_NEP_convergence_reasons_CONVERG;
static PyObject *__pyx_kp_s_NEP_convergence_test_ABS_Absolu;
static PyObject *__pyx_kp_s_NEP_desired_part_of_spectrum_LA;
static PyObject *__pyx_kp_s_NEP_error_type_to_assess_accura;
static PyObject *__pyx_kp_s_NEP_problem_type_GENERAL_Genera;
static PyObject *__pyx_kp_s_NEP_refinement_strategy_NONE_No;
static PyObject *__pyx_kp_s_NEP_scheme_for_solving_linear_s;
static PyObject *__pyx_kp_s_NEP_stopping_test_BASIC_Default;
static PyObject *__pyx_kp_s_NEP_type_Nonlinear_eigensolvers;
static PyObject *__pyx_n_s_NEVER;
static PyObject *__pyx_n_s_NHEP;
static PyObject *__pyx_n_s_NHEPTS;
static PyObject *__pyx_n_s_NLEIGS;
static PyObject *__pyx_n_s_NONE;
static PyObject *__pyx_n_s_NORM;
static PyObject *__pyx_n_s_ONESIDE;
static PyObject *__pyx_n_s_ORTHOGONAL;
static PyObject *__pyx_n_s_OrthogBlockType;
static PyObject *__pyx_n_s_OrthogRefineType;
static PyObject *__pyx_n_s_OrthogType;
static PyObject *__pyx_n_s_P;
static PyObject *__pyx_n_s_PARTIAL;
static PyObject *__pyx_n_s_PEP;
static PyObject *__pyx_n_s_PEPBasis;
static PyObject *__pyx_n_s_PEPCISSExtraction;
static PyObject *__pyx_n_s_PEPConv;
static PyObject *__pyx_n_s_PEPConvergedReason;
static PyObject *__pyx_n_s_PEPErrorType;
static PyObject *__pyx_n_s_PEPExtract;
static PyObject *__pyx_n_s_PEPJDProjection;
static PyObject *__pyx_n_s_PEPProblemType;
static PyObject *__pyx_n_s_PEPRefine;
static PyObject *__pyx_n_s_PEPRefineScheme;
static PyObject *__pyx_n_s_PEPScale;
static PyObject *__pyx_n_s_PEPStop;
static PyObject *__pyx_n_s_PEPType;
static PyObject *__pyx_n_s_PEPWhich;
static PyObject *__pyx_kp_s_PEP_CISS_extraction_technique_R;
static PyObject *__pyx_kp_s_PEP_basis_type_for_the_represen;
static PyObject *__pyx_kp_s_PEP_convergence_reasons_CONVERG;
static PyObject *__pyx_kp_s_PEP_convergence_test_ABS_Absolu;
static PyObject *__pyx_kp_s_PEP_desired_part_of_spectrum_LA;
static PyObject *__pyx_kp_s_PEP_error_type_to_assess_accura;
static PyObject *__pyx_kp_s_PEP_extraction_strategy_used_to;
static PyObject *__pyx_kp_s_PEP_problem_type_GENERAL_No_str;
static PyObject *__pyx_kp_s_PEP_refinement_strategy_NONE_No;
static PyObject *__pyx_kp_s_PEP_scaling_strategy_NONE_No_sc;
static PyObject *__pyx_kp_s_PEP_scheme_for_solving_linear_s;
static PyObject *__pyx_kp_s_PEP_stopping_test_BASIC_Default;
static PyObject *__pyx_kp_s_PEP_type_Polynomial_eigensolver;
static PyObject *__pyx_kp_s_PEP_type_of_projection_to_be_us;
static PyObject *__pyx_n_s_PERIODIC;
static PyObject *__pyx_n_s_PGNHEP;
static PyObject *__pyx_n_s_PHI;
static PyObject *__pyx_n_s_POLYGON;
static PyObject *__pyx_n_s_POWER;
static PyObject *__pyx_n_s_PRECOND;
static PyObject *__pyx_n_s_PRIMME;
static PyObject *__pyx_n_s_ParallelType;
static PyObject *__pyx_n_s_PowerShiftType;
static PyObject *__pyx_n_s_ProblemType;
static PyObject *__pyx_n_s_Q;
static PyObject *__pyx_n_s_QARNOLDI;
static PyObject *__pyx_n_s_QR;
static PyObject *__pyx_n_s_QR_CAA;
static PyObject *__pyx_n_s_QuadRule;
static PyObject *__pyx_n_s_R;
static PyObject *__pyx_n_s_RANDOMIZED;
static PyObject *__pyx_n_s_RATIONAL;
static PyObject *__pyx_n_s_RAW;
static PyObject *__pyx_n_s_RAYLEIGH;
static PyObject *__pyx_n_s_REDUNDANT;
static PyObject *__pyx_n_s_REFINE;
static PyObject *__pyx_n_s_REFINED;
static PyObject *__pyx_n_s_REFINED_HARMONIC;
static PyObject *__pyx_n_s_REL;
static PyObject *__pyx_n_s_RELATIVE;
static PyObject *__pyx_n_s_RESIDUAL;
static PyObject *__pyx_n_s_RG;
static PyObject *__pyx_n_s_RGQuadRule;
static PyObject *__pyx_n_s_RGType;
static PyObject *__pyx_kp_s_RG_quadrature_rule_for_contour;
static PyObject *__pyx_kp_s_RG_type;
static PyObject *__pyx_n_s_RII;
static PyObject *__pyx_n_s_RING;
static PyObject *__pyx_n_s_RITZ;
static PyObject *__pyx_n_s_RQCG;
static PyObject *__pyx_n_s_RealType;
static PyObject *__pyx_n_s_Refine;
static PyObject *__pyx_n_s_RefineScheme;
static PyObject *__pyx_n_s_RefineType;
static PyObject *__pyx_n_s_SCALAPACK;
static PyObject *__pyx_n_s_SCALAR;
static PyObject *__pyx_n_s_SCHUR;
static PyObject *__pyx_n_s_SELECTIVE;
static PyObject *__pyx_n_s_SHELL;
static PyObject *__pyx_n_s_SHIFT;
static PyObject *__pyx_n_s_SIMPLE;
static PyObject *__pyx_n_s_SINGLE;
static PyObject *__pyx_n_s_SINVERT;
static PyObject *__pyx_kp_s_SLEPc_SLEPc_pyx;
static PyObject *__pyx_n_s_SLP;
static PyObject *__pyx_n_s_SMALLEST;
static PyObject *__pyx_n_s_SMALLEST_IMAGINARY;
static PyObject *__pyx_n_s_SMALLEST_MAGNITUDE;
static PyObject *__pyx_n_s_SMALLEST_REAL;
static PyObject *__pyx_n_s_SQRT;
static PyObject *__pyx_n_s_ST;
static PyObject *__pyx_n_s_STANDARD;
static PyObject *__pyx_n_s_STMatMode;
static PyObject *__pyx_n_s_STOAR;
static PyObject *__pyx_n_s_STRUCTURED;
static PyObject *__pyx_n_s_STType;
static PyObject *__pyx_kp_s_ST_matrix_mode_COPY_A_working_c;
static PyObject *__pyx_kp_s_ST_types_SHELL_User_defined_SHI;
static PyObject *__pyx_n_s_SUBSPACE;
static PyObject *__pyx_n_s_SVD;
static PyObject *__pyx_n_s_SVDConv;
static PyObject *__pyx_n_s_SVDConvergedReason;
static PyObject *__pyx_n_s_SVDErrorType;
static PyObject *__pyx_n_s_SVDProblemType;
static PyObject *__pyx_n_s_SVDStop;
static PyObject *__pyx_n_s_SVDTRLanczosGBidiag;
static PyObject *__pyx_n_s_SVDType;
static PyObject *__pyx_n_s_SVDWhich;
static PyObject *__pyx_kp_s_SVD_TRLanczos_bidiagonalization;
static PyObject *__pyx_kp_s_SVD_convergence_reasons_CONVERG;
static PyObject *__pyx_kp_s_SVD_convergence_test_ABS_Absolu;
static PyObject *__pyx_kp_s_SVD_desired_part_of_spectrum_LA;
static PyObject *__pyx_kp_s_SVD_error_type_to_assess_accura;
static PyObject *__pyx_kp_s_SVD_problem_type_STANDARD_Stand;
static PyObject *__pyx_kp_s_SVD_stopping_test_BASIC_Default;
static PyObject *__pyx_kp_s_SVD_types_CROSS_Eigenproblem_wi;
static PyObject *__pyx_n_s_SVEC;
static PyObject *__pyx_n_s_SVQB;
static PyObject *__pyx_n_s_SYNCHRONIZED;
static PyObject *__pyx_kp_u_Scalable_Library_for_Eigenvalue;
static PyObject *__pyx_n_s_ScalarType;
static PyObject *__pyx_n_s_Scale;
static PyObject *__pyx_n_s_StateType;
static PyObject *__pyx_n_s_Stop;
static PyObject *__pyx_n_s_Sys;
static PyObject *__pyx_n_s_T;
static PyObject *__pyx_n_s_TARGET_IMAGINARY;
static PyObject *__pyx_n_s_TARGET_MAGNITUDE;
static PyObject *__pyx_n_s_TARGET_REAL;
static PyObject *__pyx_n_s_TENSOR;
static PyObject *__pyx_n_s_TOAR;
static PyObject *__pyx_n_s_TRAPEZOIDAL;
static PyObject *__pyx_n_s_TRLAN;
static PyObject *__pyx_n_s_TRLANCZOS;
static PyObject *__pyx_n_s_TRLanczosGBidiag;
static PyObject *__pyx_n_s_TRUNCATED;
static PyObject *__pyx_n_s_TSQR;
static PyObject *__pyx_n_s_TSQRCHOL;
static PyObject *__pyx_n_s_TWOSIDE;
static PyObject *__pyx_kp_s_To_refer_to_one_of_the_matrices;
static PyObject *__pyx_n_s_Type;
static PyObject *__pyx_n_s_TypeError;
static PyObject *__pyx_n_s_U;
static PyObject *__pyx_n_s_UPPER;
static PyObject *__pyx_n_s_USER;
static PyObject *__pyx_n_s_V;
static PyObject *__pyx_n_s_VECS;
static PyObject *__pyx_n_s_ValueError;
static PyObject *__pyx_n_s_Vi;
static PyObject *__pyx_n_s_Vr;
static PyObject *__pyx_n_s_W;
static PyObject *__pyx_n_s_WILKINSON;
static PyObject *__pyx_n_s_Which;
static PyObject *__pyx_n_s_Wi;
static PyObject *__pyx_n_s_Wr;
static PyObject *__pyx_n_s_X;
static PyObject *__pyx_n_s_Y;
static PyObject *__pyx_n_s_Z;
static PyObject *__pyx_kp_s__2;
static PyObject *__pyx_kp_s__4;
static PyObject *__pyx_n_s_a;
static PyObject *__pyx_n_s_alpha;
static PyObject *__pyx_n_s_append;
static PyObject *__pyx_n_s_arbitrary;
static PyObject *__pyx_n_s_args;
static PyObject *__pyx_n_s_author;
static PyObject *__pyx_n_s_authorinfo;
static PyObject *__pyx_n_s_b;
static PyObject *__pyx_n_s_balance;
static PyObject *__pyx_n_s_basis;
static PyObject *__pyx_n_s_beta;
static PyObject *__pyx_n_s_bidiag;
static PyObject *__pyx_n_s_block;
static PyObject *__pyx_n_s_blsize;
static PyObject *__pyx_n_s_borth;
static PyObject *__pyx_n_s_bs;
static PyObject *__pyx_n_s_bsmax;
static PyObject *__pyx_n_s_bv;
static PyObject *__pyx_n_s_bv_type;
static PyObject *__pyx_n_s_c;
static PyObject *__pyx_n_s_cct;
static PyObject *__pyx_n_s_center;
static PyObject *__pyx_n_s_cline_in_traceback;
static PyObject *__pyx_n_s_comb;
static PyObject *__pyx_n_s_comm;
static PyObject *__pyx_n_s_comp;
static PyObject *__pyx_n_s_comparison;
static PyObject *__pyx_n_s_condn;
static PyObject *__pyx_n_s_constant;
static PyObject *__pyx_n_s_conv;
static PyObject *__pyx_n_s_copy;
static PyObject *__pyx_n_s_createDense;
static PyObject *__pyx_n_s_createVecs;
static PyObject *__pyx_n_s_cutoff;
static PyObject *__pyx_n_s_d;
static PyObject *__pyx_n_s_date;
static PyObject *__pyx_n_s_decode;
static PyObject *__pyx_n_s_deftol;
static PyObject *__pyx_n_s_deg;
static PyObject *__pyx_n_s_delayed;
static PyObject *__pyx_n_s_delta;
static PyObject *__pyx_n_s_detect;
static PyObject *__pyx_n_s_devel;
static PyObject *__pyx_n_s_doc;
static PyObject *__pyx_n_s_doubleexp;
static PyObject *__pyx_n_s_ds;
static PyObject *__pyx_n_s_ds_type;
static PyObject *__pyx_n_s_duplicate;
static PyObject *__pyx_n_s_e;
static PyObject *__pyx_n_s_encode;
static PyObject *__pyx_n_s_end_ang;
static PyObject *__pyx_n_s_eps;
static PyObject *__pyx_n_s_eps_type;
static PyObject *__pyx_n_s_eta;
static PyObject *__pyx_n_s_etype;
static PyObject *__pyx_n_s_ext;
static PyObject *__pyx_n_s_extract;
static PyObject *__pyx_n_s_extraction;
static PyObject *__pyx_n_s_f;
static PyObject *__pyx_n_s_f1;
static PyObject *__pyx_n_s_f2;
static PyObject *__pyx_n_s_finalize;
static PyObject *__pyx_n_s_fix;
static PyObject *__pyx_n_s_flag;
static PyObject *__pyx_n_s_flg;
static PyObject *__pyx_n_s_fn;
static PyObject *__pyx_n_s_fn_type;
static PyObject *__pyx_n_s_fullbasis;
static PyObject *__pyx_n_s_function;
static PyObject *__pyx_n_s_getActiveColumns;
static PyObject *__pyx_n_s_getBV;
static PyObject *__pyx_n_s_getBlockSize;
static PyObject *__pyx_n_s_getCompact;
static PyObject *__pyx_n_s_getComplement;
static PyObject *__pyx_n_s_getDS;
static PyObject *__pyx_n_s_getExtraRow;
static PyObject *__pyx_n_s_getExtract;
static PyObject *__pyx_n_s_getExtraction;
static PyObject *__pyx_n_s_getFN;
static PyObject *__pyx_n_s_getKSP;
static PyObject *__pyx_n_s_getMatMode;
static PyObject *__pyx_n_s_getMatStructure;
static PyObject *__pyx_n_s_getMethod;
static PyObject *__pyx_n_s_getParallel;
static PyObject *__pyx_n_s_getProblemType;
static PyObject *__pyx_n_s_getPurify;
static PyObject *__pyx_n_s_getRG;
static PyObject *__pyx_n_s_getRefined;
static PyObject *__pyx_n_s_getST;
static PyObject *__pyx_n_s_getScale;
static PyObject *__pyx_n_s_getShift;
static PyObject *__pyx_n_s_getState;
static PyObject *__pyx_n_s_getTarget;
static PyObject *__pyx_n_s_getTolerances;
static PyObject *__pyx_n_s_getTrackAll;
static PyObject *__pyx_n_s_getTransform;
static PyObject *__pyx_n_s_getTransposeMode;
static PyObject *__pyx_n_s_getTrueResidual;
static PyObject *__pyx_n_s_getTwoSided;
static PyObject *__pyx_n_s_getVersion;
static PyObject *__pyx_n_s_getVersionInfo;
static PyObject *__pyx_n_s_getWhichEigenpairs;
static PyObject *__pyx_n_s_getWhichSingularTriplets;
static PyObject *__pyx_n_s_globalup;
static PyObject *__pyx_n_s_hasExternalPackage;
static PyObject *__pyx_n_s_herm;
static PyObject *__pyx_n_s_i;
static PyObject *__pyx_n_s_import;
static PyObject *__pyx_n_s_indef;
static PyObject *__pyx_n_s_initialize;
static PyObject *__pyx_n_s_initialsize;
static PyObject *__pyx_n_s_inner;
static PyObject *__pyx_n_s_inta;
static PyObject *__pyx_n_s_intb;
static PyObject *__pyx_n_s_ip;
static PyObject *__pyx_n_s_isFinalized;
static PyObject *__pyx_n_s_isInitialized;
static PyObject *__pyx_n_s_iterations;
static PyObject *__pyx_n_s_its;
static PyObject *__pyx_n_s_j;
static PyObject *__pyx_n_s_jacobian;
static PyObject *__pyx_n_s_k;
static PyObject *__pyx_n_s_kargs;
static PyObject *__pyx_n_s_keep;
static PyObject *__pyx_n_s_krylovstart;
static PyObject *__pyx_n_s_ksp;
static PyObject *__pyx_n_s_l;
static PyObject *__pyx_n_s_lag;
static PyObject *__pyx_n_s_lbda;
static PyObject *__pyx_n_s_ld;
static PyObject *__pyx_n_s_left;
static PyObject *__pyx_kp_s_local_and_global_sizes_cannot_be;
static PyObject *__pyx_n_s_lock;
static PyObject *__pyx_n_s_m;
static PyObject *__pyx_n_s_main;
static PyObject *__pyx_n_s_major;
static PyObject *__pyx_n_s_mat;
static PyObject *__pyx_n_s_matname;
static PyObject *__pyx_n_s_max_it;
static PyObject *__pyx_n_s_maxit;
static PyObject *__pyx_n_s_metaclass;
static PyObject *__pyx_n_s_meth;
static PyObject *__pyx_n_s_method;
static PyObject *__pyx_n_s_mfn_type;
static PyObject *__pyx_n_s_minor;
static PyObject *__pyx_n_s_minv;
static PyObject *__pyx_n_s_mode;
static PyObject *__pyx_n_s_module;
static PyObject *__pyx_n_s_monitor;
static PyObject *__pyx_n_s_mpd;
static PyObject *__pyx_n_s_ms;
static PyObject *__pyx_n_s_n;
static PyObject *__pyx_n_s_name;
static PyObject *__pyx_n_s_nc;
static PyObject *__pyx_n_s_ncv;
static PyObject *__pyx_n_s_nep_type;
static PyObject *__pyx_n_s_nev;
static PyObject *__pyx_n_s_norm_type;
static PyObject *__pyx_n_s_npart;
static PyObject *__pyx_n_s_nrest;
static PyObject *__pyx_n_s_nsv;
static PyObject *__pyx_n_s_object;
static PyObject *__pyx_n_s_omega;
static PyObject *__pyx_n_s_op;
static PyObject *__pyx_n_s_operators;
static PyObject *__pyx_n_s_orth;
static PyObject *__pyx_n_s_otype;
static PyObject *__pyx_n_s_p;
static PyObject *__pyx_n_s_p_mem;
static PyObject *__pyx_n_s_package;
static PyObject *__pyx_n_s_pbc;
static PyObject *__pyx_n_s_pep;
static PyObject *__pyx_n_s_pep_type;
static PyObject *__pyx_n_s_petsc4py_PETSc;
static PyObject *__pyx_n_s_plusk;
static PyObject *__pyx_n_s_pmode;
static PyObject *__pyx_n_s_prefix;
static PyObject *__pyx_n_s_prepare;
static PyObject *__pyx_n_s_problem_type;
static PyObject *__pyx_n_s_proj;
static PyObject *__pyx_n_s_purify;
static PyObject *__pyx_n_s_pyx_vtable;
static PyObject *__pyx_n_s_q;
static PyObject *__pyx_n_s_quad;
static PyObject *__pyx_n_s_qualname;
static PyObject *__pyx_n_s_r;
static PyObject *__pyx_n_s_radius;
static PyObject *__pyx_n_s_range;
static PyObject *__pyx_n_s_ready;
static PyObject *__pyx_n_s_realmats;
static PyObject *__pyx_n_s_ref;
static PyObject *__pyx_n_s_refine;
static PyObject *__pyx_n_s_release;
static PyObject *__pyx_n_s_reorthog;
static PyObject *__pyx_n_s_replace;
static PyObject *__pyx_n_s_restart;
static PyObject *__pyx_n_s_result;
static PyObject *__pyx_n_s_rg;
static PyObject *__pyx_n_s_rg_type;
static PyObject *__pyx_n_s_right;
static PyObject *__pyx_n_s_rkc;
static PyObject *__pyx_n_s_rkl;
static PyObject *__pyx_n_s_rnd;
static PyObject *__pyx_n_s_s;
static PyObject *__pyx_n_s_scale;
static PyObject *__pyx_n_s_scheme;
static PyObject *__pyx_n_s_setBV;
static PyObject *__pyx_n_s_setBlockSize;
static PyObject *__pyx_n_s_setCompact;
static PyObject *__pyx_n_s_setComplement;
static PyObject *__pyx_n_s_setDS;
static PyObject *__pyx_n_s_setExtraRow;
static PyObject *__pyx_n_s_setExtract;
static PyObject *__pyx_n_s_setExtraction;
static PyObject *__pyx_n_s_setKSP;
static PyObject *__pyx_n_s_setMatMode;
static PyObject *__pyx_n_s_setMatStructure;
static PyObject *__pyx_n_s_setMethod;
static PyObject *__pyx_n_s_setOperator;
static PyObject *__pyx_n_s_setOperators;
static PyObject *__pyx_n_s_setOrthogonalization;
static PyObject *__pyx_n_s_setParallel;
static PyObject *__pyx_n_s_setProblemType;
static PyObject *__pyx_n_s_setPurify;
static PyObject *__pyx_n_s_setRG;
static PyObject *__pyx_n_s_setRefined;
static PyObject *__pyx_n_s_setST;
static PyObject *__pyx_n_s_setScale;
static PyObject *__pyx_n_s_setShift;
static PyObject *__pyx_n_s_setState;
static PyObject *__pyx_n_s_setTarget;
static PyObject *__pyx_n_s_setTolerances;
static PyObject *__pyx_n_s_setTrackAll;
static PyObject *__pyx_n_s_setTransform;
static PyObject *__pyx_n_s_setTransposeMode;
static PyObject *__pyx_n_s_setTrueResidual;
static PyObject *__pyx_n_s_setTwoSided;
static PyObject *__pyx_n_s_setUp;
static PyObject *__pyx_n_s_setWhichEigenpairs;
static PyObject *__pyx_n_s_setWhichSingularTriplets;
static PyObject *__pyx_n_s_sfactor;
static PyObject *__pyx_n_s_shift;
static PyObject *__pyx_n_s_shifts;
static PyObject *__pyx_n_s_sizes;
static PyObject *__pyx_n_s_slepc4py_SLEPc;
static PyObject *__pyx_n_s_space;
static PyObject *__pyx_n_s_spaceleft;
static PyObject *__pyx_n_s_spaceright;
static PyObject *__pyx_n_s_split;
static PyObject *__pyx_n_s_spur;
static PyObject *__pyx_n_s_st;
static PyObject *__pyx_n_s_st_type;
static PyObject *__pyx_n_s_start_ang;
static PyObject *__pyx_n_s_state;
static PyObject *__pyx_n_s_stopping;
static PyObject *__pyx_n_s_strip;
static PyObject *__pyx_n_s_structure;
static PyObject *__pyx_n_s_subint;
static PyObject *__pyx_n_s_subminor;
static PyObject *__pyx_n_s_svd_type;
static PyObject *__pyx_n_s_t;
static PyObject *__pyx_n_s_target;
static PyObject *__pyx_n_s_tau;
static PyObject *__pyx_n_s_tol;
static PyObject *__pyx_n_s_trackall;
static PyObject *__pyx_n_s_trim;
static PyObject *__pyx_n_s_trueres;
static PyObject *__pyx_n_s_twosided;
static PyObject *__pyx_n_s_usest;
static PyObject *__pyx_n_s_v;
static PyObject *__pyx_n_s_vertical;
static PyObject *__pyx_n_s_viewer;
static PyObject *__pyx_n_s_vscale;
static PyObject *__pyx_n_s_w;
static PyObject *__pyx_n_s_which;
static PyObject *__pyx_n_s_width;
static PyObject *__pyx_n_s_x;
static PyObject *__pyx_n_s_y;
static int __pyx_pf_8slepc4py_5SLEPc_6_p_mem___cinit__(struct __pyx_obj_8slepc4py_5SLEPc__p_mem *__pyx_v_self); /* proto */
static void __pyx_pf_8slepc4py_5SLEPc_6_p_mem_2__dealloc__(struct __pyx_obj_8slepc4py_5SLEPc__p_mem *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3Sys_getVersion(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_devel, PyObject *__pyx_v_date, PyObject *__pyx_v_author); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3Sys_2getVersionInfo(PyTypeObject *__pyx_v_cls); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3Sys_4isInitialized(CYTHON_UNUSED PyTypeObject *__pyx_v_cls); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3Sys_6isFinalized(CYTHON_UNUSED PyTypeObject *__pyx_v_cls); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3Sys_8hasExternalPackage(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_package); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2ST___cinit__(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_2view(struct PySlepcSTObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_4destroy(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_6reset(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_8create(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_comm); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_10setType(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_st_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_12getType(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_14setOptionsPrefix(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_16getOptionsPrefix(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_18setFromOptions(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_20setShift(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_shift); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_22getShift(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_24setTransform(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_flag); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_26getTransform(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_28setMatMode(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_mode); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_30getMatMode(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_32setMatrices(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_operators); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_34getMatrices(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_36setMatStructure(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_structure); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_38getMatStructure(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_40setKSP(struct PySlepcSTObject *__pyx_v_self, struct PyPetscKSPObject *__pyx_v_ksp); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_42getKSP(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_44setPreconditionerMat(struct PySlepcSTObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_P); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_46getPreconditionerMat(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_48setUp(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_50apply(struct PySlepcSTObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_x, struct PyPetscVecObject *__pyx_v_y); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_52applyTranspose(struct PySlepcSTObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_x, struct PyPetscVecObject *__pyx_v_y); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_54applyHermitianTranspose(struct PySlepcSTObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_x, struct PyPetscVecObject *__pyx_v_y); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_56applyMat(struct PySlepcSTObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_x, struct PyPetscMatObject *__pyx_v_y); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_58getOperator(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_60restoreOperator(struct PySlepcSTObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_op); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_62setCayleyAntishift(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_tau); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_64getCayleyAntishift(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_66setFilterInterval(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_inta, PyObject *__pyx_v_intb); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_68getFilterInterval(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_70setFilterRange(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_left, PyObject *__pyx_v_right); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_72getFilterRange(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_74setFilterDegree(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_deg); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_76getFilterDegree(struct PySlepcSTObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_5shift___get__(struct PySlepcSTObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2ST_5shift_2__set__(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_9transform___get__(struct PySlepcSTObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2ST_9transform_2__set__(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_8mat_mode___get__(struct PySlepcSTObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2ST_8mat_mode_2__set__(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_13mat_structure___get__(struct PySlepcSTObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2ST_13mat_structure_2__set__(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_3ksp___get__(struct PySlepcSTObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2ST_3ksp_2__set__(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2BV___cinit__(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_2view(struct PySlepcBVObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_4destroy(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_6create(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_comm); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_8createFromMat(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_10createMat(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_12duplicate(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_14duplicateResize(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_m); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_16copy(struct PySlepcBVObject *__pyx_v_self, struct PySlepcBVObject *__pyx_v_result); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_18setType(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_bv_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_20getType(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_22setSizes(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_sizes, PyObject *__pyx_v_m); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_24setSizesFromVec(struct PySlepcBVObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_w, PyObject *__pyx_v_m); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_26getSizes(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_28setOptionsPrefix(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_30getOptionsPrefix(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_32setFromOptions(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_34getOrthogonalization(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_36setOrthogonalization(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_otype, PyObject *__pyx_v_refine, PyObject *__pyx_v_eta, PyObject *__pyx_v_block); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_38getMatMultMethod(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_40setMatMultMethod(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_method); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_42getMatrix(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_44setMatrix(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_mat, int __pyx_v_indef); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_46applyMatrix(struct PySlepcBVObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_x, struct PyPetscVecObject *__pyx_v_y); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_48setActiveColumns(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_l, PyObject *__pyx_v_k); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_50getActiveColumns(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_52scaleColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j, PyObject *__pyx_v_alpha); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_54scale(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_alpha); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_56insertVec(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j, struct PyPetscVecObject *__pyx_v_w); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_58insertVecs(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_s, PyObject *__pyx_v_W, int __pyx_v_orth); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_60insertConstraints(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_C); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_62setNumConstraints(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_nc); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_64getNumConstraints(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_66createVec(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_68copyVec(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j, struct PyPetscVecObject *__pyx_v_v); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_70copyColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j, PyObject *__pyx_v_i); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_72setDefiniteTolerance(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_deftol); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_74getDefiniteTolerance(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_76dotVec(struct PySlepcBVObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_v); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_78dotColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_80getColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_82restoreColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j, struct PyPetscVecObject *__pyx_v_v); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_84getMat(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_86restoreMat(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_88dot(struct PySlepcBVObject *__pyx_v_self, struct PySlepcBVObject *__pyx_v_Y); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_90matProject(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, struct PySlepcBVObject *__pyx_v_Y); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_92matMult(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, struct PySlepcBVObject *__pyx_v_Y); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_94matMultHermitianTranspose(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, struct PySlepcBVObject *__pyx_v_Y); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_96matMultColumn(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, PyObject *__pyx_v_j); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_98matMultTransposeColumn(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, PyObject *__pyx_v_j); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_100matMultHermitianTransposeColumn(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, PyObject *__pyx_v_j); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_102mult(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_alpha, PyObject *__pyx_v_beta, struct PySlepcBVObject *__pyx_v_X, struct PyPetscMatObject *__pyx_v_Q); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_104multInPlace(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_Q, PyObject *__pyx_v_s, PyObject *__pyx_v_e); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_106multColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_alpha, PyObject *__pyx_v_beta, PyObject *__pyx_v_j, PyObject *__pyx_v_q); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_108multVec(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_alpha, PyObject *__pyx_v_beta, struct PyPetscVecObject *__pyx_v_y, PyObject *__pyx_v_q); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_110normColumn(struct PySlepcBVObject *__pyx_v_self, int __pyx_v_j, PyObject *__pyx_v_norm_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_112norm(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_norm_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_114resize(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_m, PyObject *__pyx_v_copy); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_116setRandom(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_118setRandomNormal(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_120setRandomSign(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_122setRandomColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_124setRandomCond(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_condn); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_126setRandomContext(struct PySlepcBVObject *__pyx_v_self, struct PyPetscRandomObject *__pyx_v_rnd); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_128getRandomContext(struct PySlepcBVObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_130orthogonalizeVec(struct PySlepcBVObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_v); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_132orthogonalizeColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_134orthonormalizeColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j, PyObject *__pyx_v_replace); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_136orthogonalize(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_R, PyObject *__pyx_v_kargs); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2DS___cinit__(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_2view(struct PySlepcDSObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_4destroy(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_6reset(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_8create(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_comm); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_10setType(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_ds_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_12getType(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_14setOptionsPrefix(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_16getOptionsPrefix(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_18setFromOptions(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_20duplicate(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_22allocate(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_ld); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_24getLeadingDimension(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_26setState(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_state); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_28getState(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_30setParallel(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_pmode); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_32getParallel(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_34setDimensions(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_n, PyObject *__pyx_v_l, PyObject *__pyx_v_k); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_36getDimensions(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_38setBlockSize(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_bs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_40getBlockSize(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_42setMethod(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_meth); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_44getMethod(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_46setCompact(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_comp); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_48getCompact(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_50setExtraRow(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_ext); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_52getExtraRow(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_54setRefined(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_ref); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_56getRefined(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_58truncate(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_n, PyObject *__pyx_v_trim); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_60updateExtraRow(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_62getMat(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_matname); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_64restoreMat(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_matname, struct PyPetscMatObject *__pyx_v_mat); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_66setIdentity(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_matname); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_68cond(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_70setSVDDimensions(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_m); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_72getSVDDimensions(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_74setGSVDDimensions(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_m, PyObject *__pyx_v_p); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_76getGSVDDimensions(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_78setPEPDegree(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_deg); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_80getPEPDegree(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_82setPEPCoefficients(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_pbc); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_84getPEPCoefficients(struct PySlepcDSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_5state___get__(struct PySlepcDSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2DS_5state_2__set__(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_8parallel___get__(struct PySlepcDSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2DS_8parallel_2__set__(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_10block_size___get__(struct PySlepcDSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2DS_10block_size_2__set__(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_6method___get__(struct PySlepcDSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2DS_6method_2__set__(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_7compact___get__(struct PySlepcDSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2DS_7compact_2__set__(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_9extra_row___get__(struct PySlepcDSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2DS_9extra_row_2__set__(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_7refined___get__(struct PySlepcDSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2DS_7refined_2__set__(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2FN___cinit__(struct PySlepcFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_2view(struct PySlepcFNObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_4destroy(struct PySlepcFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_6create(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_comm); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_8setType(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_fn_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_10getType(struct PySlepcFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_12setOptionsPrefix(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_14getOptionsPrefix(struct PySlepcFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_16setFromOptions(struct PySlepcFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_18duplicate(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_comm); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_20evaluateFunction(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_x); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_22evaluateDerivative(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_x); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_24evaluateFunctionMat(struct PySlepcFNObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, struct PyPetscMatObject *__pyx_v_B); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_26evaluateFunctionMatVec(struct PySlepcFNObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, struct PyPetscVecObject *__pyx_v_v); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_28setScale(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_alpha, PyObject *__pyx_v_beta); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_30getScale(struct PySlepcFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_32setMethod(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_meth); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_34getMethod(struct PySlepcFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_36setParallel(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_pmode); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_38getParallel(struct PySlepcFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_40setRationalNumerator(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_alpha); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_42getRationalNumerator(struct PySlepcFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_44setRationalDenominator(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_alpha); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_46getRationalDenominator(struct PySlepcFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_48setCombineChildren(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_comb, struct PySlepcFNObject *__pyx_v_f1, struct PySlepcFNObject *__pyx_v_f2); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_50getCombineChildren(struct PySlepcFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_52setPhiIndex(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_k); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_54getPhiIndex(struct PySlepcFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_6method___get__(struct PySlepcFNObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2FN_6method_2__set__(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_8parallel___get__(struct PySlepcFNObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2FN_8parallel_2__set__(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2RG___cinit__(struct PySlepcRGObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_2view(struct PySlepcRGObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_4destroy(struct PySlepcRGObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_6create(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_comm); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_8setType(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_rg_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_10getType(struct PySlepcRGObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_12setOptionsPrefix(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_14getOptionsPrefix(struct PySlepcRGObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_16setFromOptions(struct PySlepcRGObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_18isTrivial(struct PySlepcRGObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_20isAxisymmetric(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_vertical); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_22getComplement(struct PySlepcRGObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_24setComplement(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_comp); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_26setScale(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_sfactor); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_28getScale(struct PySlepcRGObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_30checkInside(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_a); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_32computeContour(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_n); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_34computeBoundingBox(struct PySlepcRGObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_36canUseConjugates(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_realmats); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_38computeQuadrature(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_quad, PyObject *__pyx_v_n); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_40setEllipseParameters(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_center, PyObject *__pyx_v_radius, PyObject *__pyx_v_vscale); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_42getEllipseParameters(struct PySlepcRGObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_44setIntervalEndpoints(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_46getIntervalEndpoints(struct PySlepcRGObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_48setPolygonVertices(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_v); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_50getPolygonVertices(struct PySlepcRGObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_52setRingParameters(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_center, PyObject *__pyx_v_radius, PyObject *__pyx_v_vscale, PyObject *__pyx_v_start_ang, PyObject *__pyx_v_end_ang, PyObject *__pyx_v_width); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_54getRingParameters(struct PySlepcRGObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_10complement___get__(struct PySlepcRGObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2RG_10complement_2__set__(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_5scale___get__(struct PySlepcRGObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_2RG_5scale_2__set__(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS___cinit__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_2view(struct PySlepcEPSObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_4destroy(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_6reset(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_8create(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_comm); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_10setType(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_eps_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_12getType(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_14getOptionsPrefix(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_16setOptionsPrefix(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_18appendOptionsPrefix(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_20setFromOptions(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_22getProblemType(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_24setProblemType(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_problem_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_26isGeneralized(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_28isHermitian(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_30isPositive(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_32getBalance(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_34setBalance(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_balance, PyObject *__pyx_v_iterations, PyObject *__pyx_v_cutoff); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_36getExtraction(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_38setExtraction(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_extraction); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_40getWhichEigenpairs(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_42setWhichEigenpairs(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_which); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_44getTarget(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_46setTarget(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_target); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_48getInterval(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_50setInterval(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_inta, PyObject *__pyx_v_intb); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_52getTolerances(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_54setTolerances(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_tol, PyObject *__pyx_v_max_it); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_56getTwoSided(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_58setTwoSided(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_twosided); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_60getPurify(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_62setPurify(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_purify); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_64getConvergenceTest(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_66setConvergenceTest(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_conv); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_68getTrueResidual(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_70setTrueResidual(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_trueres); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_72getTrackAll(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_74setTrackAll(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_trackall); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_76getDimensions(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_78setDimensions(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_nev, PyObject *__pyx_v_ncv, PyObject *__pyx_v_mpd); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_80getST(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_82setST(struct PySlepcEPSObject *__pyx_v_self, struct PySlepcSTObject *__pyx_v_st); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_84getBV(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_86setBV(struct PySlepcEPSObject *__pyx_v_self, struct PySlepcBVObject *__pyx_v_bv); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_88getDS(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_90setDS(struct PySlepcEPSObject *__pyx_v_self, struct PySlepcDSObject *__pyx_v_ds); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_92getRG(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_94setRG(struct PySlepcEPSObject *__pyx_v_self, struct PySlepcRGObject *__pyx_v_rg); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_96getOperators(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_98setOperators(struct PySlepcEPSObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, struct PyPetscMatObject *__pyx_v_B); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_100setDeflationSpace(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_space); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_102setInitialSpace(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_space); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_104setLeftInitialSpace(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_space); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_106setStoppingTest(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_stopping, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_108getStoppingTest(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_110setArbitrarySelection(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_arbitrary, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_112setEigenvalueComparison(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_comparison, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_114setMonitor(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_monitor, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_116getMonitor(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_118cancelMonitor(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_120setUp(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_122solve(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_124getIterationNumber(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_126getConvergedReason(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_128getConverged(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_130getEigenvalue(struct PySlepcEPSObject *__pyx_v_self, int __pyx_v_i); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_132getEigenvector(struct PySlepcEPSObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_Vr, struct PyPetscVecObject *__pyx_v_Vi); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_134getLeftEigenvector(struct PySlepcEPSObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_Wr, struct PyPetscVecObject *__pyx_v_Wi); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_136getEigenpair(struct PySlepcEPSObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_Vr, struct PyPetscVecObject *__pyx_v_Vi); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_138getInvariantSubspace(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_140getErrorEstimate(struct PySlepcEPSObject *__pyx_v_self, int __pyx_v_i); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_142computeError(struct PySlepcEPSObject *__pyx_v_self, int __pyx_v_i, PyObject *__pyx_v_etype); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_144errorView(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_etype, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_146valuesView(struct PySlepcEPSObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_148vectorsView(struct PySlepcEPSObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_150setPowerShiftType(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_shift); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_152getPowerShiftType(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_154setArnoldiDelayed(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_delayed); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_156getArnoldiDelayed(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_158setLanczosReorthogType(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_reorthog); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_160getLanczosReorthogType(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_162setKrylovSchurRestart(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_keep); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_164getKrylovSchurRestart(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_166setKrylovSchurLocking(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_lock); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_168getKrylovSchurLocking(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_170setKrylovSchurPartitions(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_npart); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_172getKrylovSchurPartitions(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_174setKrylovSchurDetectZeros(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_detect); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_176getKrylovSchurDetectZeros(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_178setKrylovSchurDimensions(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_nev, PyObject *__pyx_v_ncv, PyObject *__pyx_v_mpd); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_180getKrylovSchurDimensions(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_182getKrylovSchurSubcommInfo(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_184getKrylovSchurSubcommPairs(struct PySlepcEPSObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_V); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_186getKrylovSchurSubcommMats(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_188updateKrylovSchurSubcommMats(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_s, PyObject *__pyx_v_a, struct PyPetscMatObject *__pyx_v_Au, PyObject *__pyx_v_t, PyObject *__pyx_v_b, struct PyPetscMatObject *__pyx_v_Bu, PyObject *__pyx_v_structure, PyObject *__pyx_v_globalup); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_190setKrylovSchurSubintervals(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_subint); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_192getKrylovSchurSubintervals(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_194getKrylovSchurInertias(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_196getKrylovSchurKSP(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_198setGDKrylovStart(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_krylovstart); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_200getGDKrylovStart(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_202setGDBlockSize(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_bs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_204getGDBlockSize(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_206setGDRestart(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_minv, PyObject *__pyx_v_plusk); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_208getGDRestart(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_210setGDInitialSize(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_initialsize); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_212getGDInitialSize(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_214setGDBOrth(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_borth); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_216getGDBOrth(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_218setGDDoubleExpansion(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_doubleexp); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_220getGDDoubleExpansion(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_222setJDKrylovStart(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_krylovstart); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_224getJDKrylovStart(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_226setJDBlockSize(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_bs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_228getJDBlockSize(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_230setJDRestart(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_minv, PyObject *__pyx_v_plusk); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_232getJDRestart(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_234setJDInitialSize(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_initialsize); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_236getJDInitialSize(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_238setJDFix(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_fix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_240getJDFix(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_242setJDConstCorrectionTol(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_constant); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_244getJDConstCorrectionTol(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_246setJDBOrth(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_borth); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_248getJDBOrth(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_250setRQCGReset(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_nrest); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_252getRQCGReset(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_254setLOBPCGBlockSize(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_bs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_256getLOBPCGBlockSize(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_258setLOBPCGRestart(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_restart); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_260getLOBPCGRestart(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_262setLOBPCGLocking(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_lock); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_264getLOBPCGLocking(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_266setLyapIIRanks(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_rkc, PyObject *__pyx_v_rkl); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_268getLyapIIRanks(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_270setCISSExtraction(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_extraction); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_272getCISSExtraction(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_274setCISSQuadRule(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_quad); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_276getCISSQuadRule(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_278setCISSSizes(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_ip, PyObject *__pyx_v_bs, PyObject *__pyx_v_ms, PyObject *__pyx_v_npart, PyObject *__pyx_v_bsmax, PyObject *__pyx_v_realmats); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_280getCISSSizes(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_282setCISSThreshold(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_delta, PyObject *__pyx_v_spur); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_284getCISSThreshold(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_286setCISSRefinement(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_inner, PyObject *__pyx_v_blsize); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_288getCISSRefinement(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_290setCISSUseST(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_usest); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_292getCISSUseST(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_294getCISSKSPs(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_12problem_type___get__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS_12problem_type_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_10extraction___get__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS_10extraction_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_5which___get__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS_5which_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_6target___get__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS_6target_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_3tol___get__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS_3tol_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_6max_it___get__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS_6max_it_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_9two_sided___get__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS_9two_sided_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_13true_residual___get__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS_13true_residual_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_6purify___get__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS_6purify_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_9track_all___get__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS_9track_all_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_2st___get__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS_2st_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_2bv___get__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS_2bv_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_2rg___get__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS_2rg_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_2ds___get__(struct PySlepcEPSObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3EPS_2ds_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3SVD___cinit__(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_2view(struct PySlepcSVDObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_4destroy(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_6reset(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_8create(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_comm); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_10setType(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_svd_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_12getType(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_14getOptionsPrefix(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_16setOptionsPrefix(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_18appendOptionsPrefix(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_20setFromOptions(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_22getProblemType(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_24setProblemType(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_problem_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_26isGeneralized(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_28isHyperbolic(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_30getImplicitTranspose(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_32setImplicitTranspose(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_mode); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_34getWhichSingularTriplets(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_36setWhichSingularTriplets(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_which); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_38getTolerances(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_40setTolerances(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_tol, PyObject *__pyx_v_max_it); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_42getConvergenceTest(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_44setConvergenceTest(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_conv); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_46getTrackAll(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_48setTrackAll(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_trackall); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_50getDimensions(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_52setDimensions(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_nsv, PyObject *__pyx_v_ncv, PyObject *__pyx_v_mpd); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_54getBV(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_56setBV(struct PySlepcSVDObject *__pyx_v_self, struct PySlepcBVObject *__pyx_v_V, struct PySlepcBVObject *__pyx_v_U); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_58getDS(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_60setDS(struct PySlepcSVDObject *__pyx_v_self, struct PySlepcDSObject *__pyx_v_ds); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_62getOperators(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_64setOperators(struct PySlepcSVDObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, struct PyPetscMatObject *__pyx_v_B); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_66getSignature(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_68setSignature(struct PySlepcSVDObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_omega); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_70setInitialSpaces(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_spaceright, PyObject *__pyx_v_spaceleft); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_72setStoppingTest(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_stopping, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_74getStoppingTest(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_76setMonitor(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_monitor, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_78getMonitor(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_80cancelMonitor(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_82setUp(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_84solve(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_86getIterationNumber(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_88getConvergedReason(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_90getConverged(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_92getValue(struct PySlepcSVDObject *__pyx_v_self, int __pyx_v_i); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_94getVectors(struct PySlepcSVDObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_U, struct PyPetscVecObject *__pyx_v_V); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_96getSingularTriplet(struct PySlepcSVDObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_U, struct PyPetscVecObject *__pyx_v_V); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_98computeError(struct PySlepcSVDObject *__pyx_v_self, int __pyx_v_i, PyObject *__pyx_v_etype); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_100errorView(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_etype, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_102valuesView(struct PySlepcSVDObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_104vectorsView(struct PySlepcSVDObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_106setCrossEPS(struct PySlepcSVDObject *__pyx_v_self, struct PySlepcEPSObject *__pyx_v_eps); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_108getCrossEPS(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_110setCrossExplicitMatrix(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_flag); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_112getCrossExplicitMatrix(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_114setCyclicEPS(struct PySlepcSVDObject *__pyx_v_self, struct PySlepcEPSObject *__pyx_v_eps); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_116getCyclicEPS(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_118setCyclicExplicitMatrix(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_flag); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_120getCyclicExplicitMatrix(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_122setLanczosOneSide(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_flag); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_124getLanczosOneSide(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_126setTRLanczosOneSide(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_flag); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_128getTRLanczosOneSide(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_130setTRLanczosGBidiag(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_bidiag); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_132getTRLanczosGBidiag(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_134setTRLanczosRestart(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_keep); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_136getTRLanczosRestart(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_138setTRLanczosLocking(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_lock); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_140getTRLanczosLocking(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_142setTRLanczosKSP(struct PySlepcSVDObject *__pyx_v_self, struct PyPetscKSPObject *__pyx_v_ksp); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_144getTRLanczosKSP(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_146setTRLanczosExplicitMatrix(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_flag); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_148getTRLanczosExplicitMatrix(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_12problem_type___get__(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3SVD_12problem_type_2__set__(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_14transpose_mode___get__(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3SVD_14transpose_mode_2__set__(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_5which___get__(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3SVD_5which_2__set__(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_3tol___get__(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3SVD_3tol_2__set__(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_6max_it___get__(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3SVD_6max_it_2__set__(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_9track_all___get__(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3SVD_9track_all_2__set__(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_2ds___get__(struct PySlepcSVDObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3SVD_2ds_2__set__(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3PEP___cinit__(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_2view(struct PySlepcPEPObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_4destroy(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_6reset(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_8create(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_comm); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_10setType(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_pep_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_12getType(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_14getOptionsPrefix(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_16setOptionsPrefix(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_18appendOptionsPrefix(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_20setFromOptions(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_22getBasis(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_24setBasis(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_basis); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_26getProblemType(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_28setProblemType(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_problem_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_30getWhichEigenpairs(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_32setWhichEigenpairs(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_which); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_34getTarget(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_36setTarget(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_target); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_38getTolerances(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_40setTolerances(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_tol, PyObject *__pyx_v_max_it); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_42getInterval(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_44setInterval(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_inta, PyObject *__pyx_v_intb); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_46getConvergenceTest(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_48setConvergenceTest(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_conv); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_50getRefine(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_52setRefine(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_ref, PyObject *__pyx_v_npart, PyObject *__pyx_v_tol, PyObject *__pyx_v_its, PyObject *__pyx_v_scheme); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_54getRefineKSP(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_56setExtract(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_extract); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_58getExtract(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_60getTrackAll(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_62setTrackAll(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_trackall); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_64getDimensions(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_66setDimensions(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_nev, PyObject *__pyx_v_ncv, PyObject *__pyx_v_mpd); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_68getST(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_70setST(struct PySlepcPEPObject *__pyx_v_self, struct PySlepcSTObject *__pyx_v_st); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_72getScale(struct PySlepcPEPObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_Dl, struct PyPetscVecObject *__pyx_v_Dr); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_74setScale(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_scale, PyObject *__pyx_v_alpha, struct PyPetscVecObject *__pyx_v_Dl, struct PyPetscVecObject *__pyx_v_Dr, PyObject *__pyx_v_its, PyObject *__pyx_v_lbda); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_76getBV(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_78setBV(struct PySlepcPEPObject *__pyx_v_self, struct PySlepcBVObject *__pyx_v_bv); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_80getRG(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_82setRG(struct PySlepcPEPObject *__pyx_v_self, struct PySlepcRGObject *__pyx_v_rg); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_84getDS(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_86setDS(struct PySlepcPEPObject *__pyx_v_self, struct PySlepcDSObject *__pyx_v_ds); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_88getOperators(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_90setOperators(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_operators); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_92setInitialSpace(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_space); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_94setStoppingTest(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_stopping, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_96getStoppingTest(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_98setMonitor(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_monitor, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_100getMonitor(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_102cancelMonitor(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_104setUp(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_106solve(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_108getIterationNumber(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_110getConvergedReason(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_112getConverged(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_114getEigenpair(struct PySlepcPEPObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_Vr, struct PyPetscVecObject *__pyx_v_Vi); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_116getErrorEstimate(struct PySlepcPEPObject *__pyx_v_self, int __pyx_v_i); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_118computeError(struct PySlepcPEPObject *__pyx_v_self, int __pyx_v_i, PyObject *__pyx_v_etype); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_120errorView(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_etype, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_122valuesView(struct PySlepcPEPObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_124vectorsView(struct PySlepcPEPObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_126setLinearEPS(struct PySlepcPEPObject *__pyx_v_self, struct PySlepcEPSObject *__pyx_v_eps); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_128getLinearEPS(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_130setLinearLinearization(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_alpha, PyObject *__pyx_v_beta); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_132getLinearLinearization(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_134setLinearExplicitMatrix(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_flag); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_136getLinearExplicitMatrix(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_138setQArnoldiRestart(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_keep); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_140getQArnoldiRestart(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_142setQArnoldiLocking(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_lock); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_144getQArnoldiLocking(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_146setTOARRestart(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_keep); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_148getTOARRestart(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_150setTOARLocking(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_lock); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_152getTOARLocking(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_154setSTOARLinearization(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_alpha, PyObject *__pyx_v_beta); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_156getSTOARLinearization(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_158setSTOARLocking(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_lock); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_160getSTOARLocking(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_162setSTOARDetectZeros(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_detect); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_164getSTOARDetectZeros(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_166setSTOARDimensions(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_nev, PyObject *__pyx_v_ncv, PyObject *__pyx_v_mpd); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_168getSTOARDimensions(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_170getSTOARInertias(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_172setSTOARCheckEigenvalueType(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_flag); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_174getSTOARCheckEigenvalueType(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_176setJDRestart(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_keep); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_178getJDRestart(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_180setJDFix(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_fix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_182getJDFix(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_184setJDReusePreconditioner(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_flag); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_186getJDReusePreconditioner(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_188setJDMinimalityIndex(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_flag); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_190getJDMinimalityIndex(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_192setJDProjection(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_proj); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_194getJDProjection(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_196setCISSExtraction(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_extraction); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_198getCISSExtraction(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_200setCISSSizes(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_ip, PyObject *__pyx_v_bs, PyObject *__pyx_v_ms, PyObject *__pyx_v_npart, PyObject *__pyx_v_bsmax, PyObject *__pyx_v_realmats); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_202getCISSSizes(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_204setCISSThreshold(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_delta, PyObject *__pyx_v_spur); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_206getCISSThreshold(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_208setCISSRefinement(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_inner, PyObject *__pyx_v_blsize); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_210getCISSRefinement(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_212getCISSKSPs(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_12problem_type___get__(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3PEP_12problem_type_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_5which___get__(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3PEP_5which_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_6target___get__(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3PEP_6target_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_7extract___get__(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3PEP_7extract_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_3tol___get__(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3PEP_3tol_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_6max_it___get__(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3PEP_6max_it_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_9track_all___get__(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3PEP_9track_all_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_2st___get__(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3PEP_2st_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_2bv___get__(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3PEP_2bv_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_2rg___get__(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3PEP_2rg_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_2ds___get__(struct PySlepcPEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3PEP_2ds_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3NEP___cinit__(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_2view(struct PySlepcNEPObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_4destroy(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_6reset(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_8create(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_comm); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_10setType(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_nep_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_12getType(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_14getOptionsPrefix(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_16setOptionsPrefix(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_18appendOptionsPrefix(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_20setFromOptions(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_22getProblemType(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_24setProblemType(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_problem_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_26getWhichEigenpairs(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_28setWhichEigenpairs(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_which); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_30getTarget(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_32setTarget(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_target); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_34getTolerances(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_36setTolerances(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_tol, PyObject *__pyx_v_maxit); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_38getConvergenceTest(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_40setConvergenceTest(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_conv); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_42getRefine(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_44setRefine(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_ref, PyObject *__pyx_v_npart, PyObject *__pyx_v_tol, PyObject *__pyx_v_its, PyObject *__pyx_v_scheme); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_46getRefineKSP(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_48getTrackAll(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_50setTrackAll(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_trackall); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_52getDimensions(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_54setDimensions(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_nev, PyObject *__pyx_v_ncv, PyObject *__pyx_v_mpd); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_56getBV(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_58setBV(struct PySlepcNEPObject *__pyx_v_self, struct PySlepcBVObject *__pyx_v_bv); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_60getRG(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_62setRG(struct PySlepcNEPObject *__pyx_v_self, struct PySlepcRGObject *__pyx_v_rg); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_64getDS(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_66setDS(struct PySlepcNEPObject *__pyx_v_self, struct PySlepcDSObject *__pyx_v_ds); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_68setInitialSpace(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_space); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_70setStoppingTest(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_stopping, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_72getStoppingTest(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_74setMonitor(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_monitor, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_76getMonitor(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_78cancelMonitor(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_80setUp(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_82solve(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_84getIterationNumber(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_86getConvergedReason(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_88getConverged(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_90getEigenpair(struct PySlepcNEPObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_Vr, struct PyPetscVecObject *__pyx_v_Vi); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_92getLeftEigenvector(struct PySlepcNEPObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_Wr, struct PyPetscVecObject *__pyx_v_Wi); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_94getErrorEstimate(struct PySlepcNEPObject *__pyx_v_self, int __pyx_v_i); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_96computeError(struct PySlepcNEPObject *__pyx_v_self, int __pyx_v_i, PyObject *__pyx_v_etype); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_98errorView(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_etype, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_100valuesView(struct PySlepcNEPObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_102vectorsView(struct PySlepcNEPObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_104setFunction(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_function, struct PyPetscMatObject *__pyx_v_F, struct PyPetscMatObject *__pyx_v_P, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_106getFunction(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_108setJacobian(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_jacobian, struct PyPetscMatObject *__pyx_v_J, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_110getJacobian(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_112setSplitOperator(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_A, PyObject *__pyx_v_f, PyObject *__pyx_v_structure); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_114getSplitOperator(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_116setSplitPreconditioner(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_P, PyObject *__pyx_v_structure); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_118getSplitPreconditioner(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_120getTwoSided(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_122setTwoSided(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_twosided); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_124applyResolvent(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_omega, struct PyPetscVecObject *__pyx_v_v, struct PyPetscVecObject *__pyx_v_r, struct PySlepcRGObject *__pyx_v_rg); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_126setRIILagPreconditioner(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_lag); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_128getRIILagPreconditioner(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_130setRIIConstCorrectionTol(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_cct); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_132getRIIConstCorrectionTol(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_134setRIIMaximumIterations(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_its); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_136getRIIMaximumIterations(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_138setRIIHermitian(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_herm); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_140getRIIHermitian(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_142setRIIDeflationThreshold(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_deftol); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_144getRIIDeflationThreshold(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_146setRIIKSP(struct PySlepcNEPObject *__pyx_v_self, struct PyPetscKSPObject *__pyx_v_ksp); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_148getRIIKSP(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_150setSLPDeflationThreshold(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_deftol); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_152getSLPDeflationThreshold(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_154setSLPEPS(struct PySlepcNEPObject *__pyx_v_self, struct PySlepcEPSObject *__pyx_v_eps); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_156getSLPEPS(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_158setSLPEPSLeft(struct PySlepcNEPObject *__pyx_v_self, struct PySlepcEPSObject *__pyx_v_eps); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_160getSLPEPSLeft(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_162setSLPKSP(struct PySlepcNEPObject *__pyx_v_self, struct PyPetscKSPObject *__pyx_v_ksp); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_164getSLPKSP(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_166setNArnoldiKSP(struct PySlepcNEPObject *__pyx_v_self, struct PyPetscKSPObject *__pyx_v_ksp); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_168getNArnoldiKSP(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_170setNArnoldiLagPreconditioner(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_lag); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_172getNArnoldiLagPreconditioner(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_174setInterpolPEP(struct PySlepcNEPObject *__pyx_v_self, struct PySlepcPEPObject *__pyx_v_pep); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_176getInterpolPEP(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_178setInterpolInterpolation(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_tol, PyObject *__pyx_v_deg); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_180getInterpolInterpolation(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_182setNLEIGSRestart(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_keep); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_184getNLEIGSRestart(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_186setNLEIGSLocking(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_lock); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_188getNLEIGSLocking(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_190setNLEIGSInterpolation(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_tol, PyObject *__pyx_v_deg); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_192getNLEIGSInterpolation(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_194setNLEIGSFullBasis(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_fullbasis); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_196getNLEIGSFullBasis(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_198setNLEIGSEPS(struct PySlepcNEPObject *__pyx_v_self, struct PySlepcEPSObject *__pyx_v_eps); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_200getNLEIGSEPS(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_202setNLEIGSRKShifts(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_shifts); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_204getNLEIGSRKShifts(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_206getNLEIGSKSPs(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_208setCISSExtraction(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_extraction); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_210getCISSExtraction(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_212setCISSSizes(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_ip, PyObject *__pyx_v_bs, PyObject *__pyx_v_ms, PyObject *__pyx_v_npart, PyObject *__pyx_v_bsmax, PyObject *__pyx_v_realmats); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_214getCISSSizes(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_216setCISSThreshold(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_delta, PyObject *__pyx_v_spur); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_218getCISSThreshold(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_220setCISSRefinement(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_inner, PyObject *__pyx_v_blsize); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_222getCISSRefinement(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_224getCISSKSPs(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_12problem_type___get__(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3NEP_12problem_type_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_5which___get__(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3NEP_5which_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_6target___get__(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3NEP_6target_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_3tol___get__(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3NEP_3tol_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_6max_it___get__(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3NEP_6max_it_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_9track_all___get__(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3NEP_9track_all_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_2bv___get__(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3NEP_2bv_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_2rg___get__(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3NEP_2rg_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_2ds___get__(struct PySlepcNEPObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3NEP_2ds_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3MFN___cinit__(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_2view(struct PySlepcMFNObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_4destroy(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_6reset(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_8create(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_comm); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_10setType(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_mfn_type); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_12getType(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_14getOptionsPrefix(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_16setOptionsPrefix(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_18appendOptionsPrefix(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_prefix); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_20setFromOptions(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_22getTolerances(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_24setTolerances(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_tol, PyObject *__pyx_v_max_it); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_26getDimensions(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_28setDimensions(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_ncv); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_30getFN(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_32setFN(struct PySlepcMFNObject *__pyx_v_self, struct PySlepcFNObject *__pyx_v_fn); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_34getBV(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_36setBV(struct PySlepcMFNObject *__pyx_v_self, struct PySlepcBVObject *__pyx_v_bv); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_38getOperator(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_40setOperator(struct PySlepcMFNObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_42setMonitor(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_monitor, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_44getMonitor(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_46cancelMonitor(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_48setUp(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_50solve(struct PySlepcMFNObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_b, struct PyPetscVecObject *__pyx_v_x); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_52solveTranspose(struct PySlepcMFNObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_b, struct PyPetscVecObject *__pyx_v_x); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_54getIterationNumber(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_56getConvergedReason(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_58setErrorIfNotConverged(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_flg); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_60getErrorIfNotConverged(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_3tol___get__(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3MFN_3tol_2__set__(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_6max_it___get__(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3MFN_6max_it_2__set__(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_2fn___get__(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3MFN_2fn_2__set__(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_2bv___get__(struct PySlepcMFNObject *__pyx_v_self); /* proto */
static int __pyx_pf_8slepc4py_5SLEPc_3MFN_2bv_2__set__(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc__initialize(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_args); /* proto */
static PyObject *__pyx_pf_8slepc4py_5SLEPc_2_finalize(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_ST(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_BV(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_DS(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_FN(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_RG(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_EPS(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_SVD(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_PEP(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_NEP(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_MFN(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_8slepc4py_5SLEPc__p_mem(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_Sys(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_float_0_0;
static PyObject *__pyx_float_1_0;
static PyObject *__pyx_int_1;
static PyObject *__pyx_tuple_;
static PyObject *__pyx_tuple__3;
static PyObject *__pyx_tuple__5;
static PyObject *__pyx_tuple__6;
static PyObject *__pyx_tuple__7;
static PyObject *__pyx_tuple__8;
static PyObject *__pyx_tuple__9;
static PyObject *__pyx_tuple__10;
static PyObject *__pyx_tuple__11;
static PyObject *__pyx_tuple__12;
static PyObject *__pyx_tuple__13;
static PyObject *__pyx_tuple__14;
static PyObject *__pyx_tuple__15;
static PyObject *__pyx_tuple__16;
static PyObject *__pyx_tuple__17;
static PyObject *__pyx_tuple__18;
static PyObject *__pyx_tuple__19;
static PyObject *__pyx_tuple__20;
static PyObject *__pyx_tuple__21;
static PyObject *__pyx_tuple__22;
static PyObject *__pyx_tuple__23;
static PyObject *__pyx_tuple__24;
static PyObject *__pyx_tuple__25;
static PyObject *__pyx_tuple__26;
static PyObject *__pyx_tuple__27;
static PyObject *__pyx_tuple__28;
static PyObject *__pyx_tuple__29;
static PyObject *__pyx_tuple__30;
static PyObject *__pyx_tuple__31;
static PyObject *__pyx_tuple__32;
static PyObject *__pyx_tuple__33;
static PyObject *__pyx_tuple__34;
static PyObject *__pyx_tuple__35;
static PyObject *__pyx_tuple__36;
static PyObject *__pyx_tuple__37;
static PyObject *__pyx_tuple__38;
static PyObject *__pyx_tuple__39;
static PyObject *__pyx_tuple__40;
static PyObject *__pyx_tuple__41;
static PyObject *__pyx_tuple__42;
static PyObject *__pyx_tuple__43;
static PyObject *__pyx_tuple__44;
static PyObject *__pyx_tuple__45;
static PyObject *__pyx_tuple__46;
static PyObject *__pyx_tuple__47;
static PyObject *__pyx_tuple__48;
static PyObject *__pyx_tuple__49;
static PyObject *__pyx_tuple__50;
static PyObject *__pyx_tuple__51;
static PyObject *__pyx_tuple__52;
static PyObject *__pyx_tuple__53;
static PyObject *__pyx_tuple__54;
static PyObject *__pyx_tuple__55;
static PyObject *__pyx_tuple__56;
static PyObject *__pyx_tuple__57;
static PyObject *__pyx_tuple__58;
static PyObject *__pyx_tuple__59;
static PyObject *__pyx_tuple__60;
static PyObject *__pyx_tuple__61;
static PyObject *__pyx_tuple__62;
static PyObject *__pyx_tuple__63;
static PyObject *__pyx_tuple__64;
static PyObject *__pyx_tuple__65;
static PyObject *__pyx_tuple__66;
static PyObject *__pyx_tuple__67;
static PyObject *__pyx_tuple__68;
static PyObject *__pyx_tuple__69;
static PyObject *__pyx_tuple__70;
static PyObject *__pyx_codeobj__71;
static PyObject *__pyx_codeobj__72;
/* Late includes */

/* "SLEPc/SLEPc.pyx":26
 *     ctypedef char const_char "const char"
 * 
 * cdef inline object bytes2str(const_char p[]):             # <<<<<<<<<<<<<<
 *      if p == NULL:
 *          return None
 */

static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_bytes2str(const char *__pyx_v_p) {
  PyObject *__pyx_v_s = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("bytes2str", 0);

  /* "SLEPc/SLEPc.pyx":27
 * 
 * cdef inline object bytes2str(const_char p[]):
 *      if p == NULL:             # <<<<<<<<<<<<<<
 *          return None
 *      cdef bytes s = <char*>p
 */
  __pyx_t_1 = ((__pyx_v_p == NULL) != 0);
  if (__pyx_t_1) {

    /* "SLEPc/SLEPc.pyx":28
 * cdef inline object bytes2str(const_char p[]):
 *      if p == NULL:
 *          return None             # <<<<<<<<<<<<<<
 *      cdef bytes s = <char*>p
 *      if isinstance(s, str):
 */
    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;

    /* "SLEPc/SLEPc.pyx":27
 * 
 * cdef inline object bytes2str(const_char p[]):
 *      if p == NULL:             # <<<<<<<<<<<<<<
 *          return None
 *      cdef bytes s = <char*>p
 */
  }

  /* "SLEPc/SLEPc.pyx":29
 *      if p == NULL:
 *          return None
 *      cdef bytes s = <char*>p             # <<<<<<<<<<<<<<
 *      if isinstance(s, str):
 *          return s
 */
  __pyx_t_2 = __Pyx_PyBytes_FromString(((char *)__pyx_v_p)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 29, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_s = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/SLEPc.pyx":30
 *          return None
 *      cdef bytes s = <char*>p
 *      if isinstance(s, str):             # <<<<<<<<<<<<<<
 *          return s
 *      else:
 */
  __pyx_t_1 = PyString_Check(__pyx_v_s); 
  __pyx_t_3 = (__pyx_t_1 != 0);
  if (__pyx_t_3) {

    /* "SLEPc/SLEPc.pyx":31
 *      cdef bytes s = <char*>p
 *      if isinstance(s, str):
 *          return s             # <<<<<<<<<<<<<<
 *      else:
 *          return s.decode()
 */
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_s);
    __pyx_r = __pyx_v_s;
    goto __pyx_L0;

    /* "SLEPc/SLEPc.pyx":30
 *          return None
 *      cdef bytes s = <char*>p
 *      if isinstance(s, str):             # <<<<<<<<<<<<<<
 *          return s
 *      else:
 */
  }

  /* "SLEPc/SLEPc.pyx":33
 *          return s
 *      else:
 *          return s.decode()             # <<<<<<<<<<<<<<
 * 
 * cdef inline object str2bytes(object s, const_char *p[]):
 */
  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_2 = __Pyx_decode_bytes(__pyx_v_s, 0, PY_SSIZE_T_MAX, NULL, NULL, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 33, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;
  }

  /* "SLEPc/SLEPc.pyx":26
 *     ctypedef char const_char "const char"
 * 
 * cdef inline object bytes2str(const_char p[]):             # <<<<<<<<<<<<<<
 *      if p == NULL:
 *          return None
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_s);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":35
 *          return s.decode()
 * 
 * cdef inline object str2bytes(object s, const_char *p[]):             # <<<<<<<<<<<<<<
 *     if s is None:
 *         p[0] = NULL
 */

static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_str2bytes(PyObject *__pyx_v_s, const char **__pyx_v_p) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  char *__pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("str2bytes", 0);
  __Pyx_INCREF(__pyx_v_s);

  /* "SLEPc/SLEPc.pyx":36
 * 
 * cdef inline object str2bytes(object s, const_char *p[]):
 *     if s is None:             # <<<<<<<<<<<<<<
 *         p[0] = NULL
 *         return None
 */
  __pyx_t_1 = (__pyx_v_s == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "SLEPc/SLEPc.pyx":37
 * cdef inline object str2bytes(object s, const_char *p[]):
 *     if s is None:
 *         p[0] = NULL             # <<<<<<<<<<<<<<
 *         return None
 *     if not isinstance(s, bytes):
 */
    (__pyx_v_p[0]) = NULL;

    /* "SLEPc/SLEPc.pyx":38
 *     if s is None:
 *         p[0] = NULL
 *         return None             # <<<<<<<<<<<<<<
 *     if not isinstance(s, bytes):
 *         s = s.encode()
 */
    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;

    /* "SLEPc/SLEPc.pyx":36
 * 
 * cdef inline object str2bytes(object s, const_char *p[]):
 *     if s is None:             # <<<<<<<<<<<<<<
 *         p[0] = NULL
 *         return None
 */
  }

  /* "SLEPc/SLEPc.pyx":39
 *         p[0] = NULL
 *         return None
 *     if not isinstance(s, bytes):             # <<<<<<<<<<<<<<
 *         s = s.encode()
 *     p[0] = <const_char*>(<char*>s)
 */
  __pyx_t_2 = PyBytes_Check(__pyx_v_s); 
  __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
  if (__pyx_t_1) {

    /* "SLEPc/SLEPc.pyx":40
 *         return None
 *     if not isinstance(s, bytes):
 *         s = s.encode()             # <<<<<<<<<<<<<<
 *     p[0] = <const_char*>(<char*>s)
 *     return s
 */
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_s, __pyx_n_s_encode); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 40, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = NULL;
    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
      if (likely(__pyx_t_5)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_4, function);
      }
    }
    __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 40, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF_SET(__pyx_v_s, __pyx_t_3);
    __pyx_t_3 = 0;

    /* "SLEPc/SLEPc.pyx":39
 *         p[0] = NULL
 *         return None
 *     if not isinstance(s, bytes):             # <<<<<<<<<<<<<<
 *         s = s.encode()
 *     p[0] = <const_char*>(<char*>s)
 */
  }

  /* "SLEPc/SLEPc.pyx":41
 *     if not isinstance(s, bytes):
 *         s = s.encode()
 *     p[0] = <const_char*>(<char*>s)             # <<<<<<<<<<<<<<
 *     return s
 * 
 */
  __pyx_t_6 = __Pyx_PyObject_AsWritableString(__pyx_v_s); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(4, 41, __pyx_L1_error)
  (__pyx_v_p[0]) = ((const char *)((char *)__pyx_t_6));

  /* "SLEPc/SLEPc.pyx":42
 *         s = s.encode()
 *     p[0] = <const_char*>(<char*>s)
 *     return s             # <<<<<<<<<<<<<<
 * 
 * cdef inline object S_(const_char p[]):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_s);
  __pyx_r = __pyx_v_s;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":35
 *          return s.decode()
 * 
 * cdef inline object str2bytes(object s, const_char *p[]):             # <<<<<<<<<<<<<<
 *     if s is None:
 *         p[0] = NULL
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_s);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":44
 *     return s
 * 
 * cdef inline object S_(const_char p[]):             # <<<<<<<<<<<<<<
 *      if p == NULL: return None
 *      cdef object s = <char*>p
 */

static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_S_(const char *__pyx_v_p) {
  PyObject *__pyx_v_s = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("S_", 0);

  /* "SLEPc/SLEPc.pyx":45
 * 
 * cdef inline object S_(const_char p[]):
 *      if p == NULL: return None             # <<<<<<<<<<<<<<
 *      cdef object s = <char*>p
 *      return s if isinstance(s, str) else s.decode()
 */
  __pyx_t_1 = ((__pyx_v_p == NULL) != 0);
  if (__pyx_t_1) {
    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;
  }

  /* "SLEPc/SLEPc.pyx":46
 * cdef inline object S_(const_char p[]):
 *      if p == NULL: return None
 *      cdef object s = <char*>p             # <<<<<<<<<<<<<<
 *      return s if isinstance(s, str) else s.decode()
 * 
 */
  __pyx_t_2 = __Pyx_PyBytes_FromString(((char *)__pyx_v_p)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 46, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_s = __pyx_t_2;
  __pyx_t_2 = 0;

  /* "SLEPc/SLEPc.pyx":47
 *      if p == NULL: return None
 *      cdef object s = <char*>p
 *      return s if isinstance(s, str) else s.decode()             # <<<<<<<<<<<<<<
 * 
 * include "allocate.pxi"
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyString_Check(__pyx_v_s); 
  if ((__pyx_t_1 != 0)) {
    __Pyx_INCREF(__pyx_v_s);
    __pyx_t_2 = __pyx_v_s;
  } else {
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_s, __pyx_n_s_decode); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 47, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = NULL;
    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
      if (likely(__pyx_t_5)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_4, function);
      }
    }
    __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 47, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_2 = __pyx_t_3;
    __pyx_t_3 = 0;
  }
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":44
 *     return s
 * 
 * cdef inline object S_(const_char p[]):             # <<<<<<<<<<<<<<
 *      if p == NULL: return None
 *      cdef object s = <char*>p
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.S_", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_s);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/allocate.pxi":13
 * cdef class _p_mem:
 *     cdef void *buf
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.buf = NULL
 *     def __dealloc__(self):
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_6_p_mem_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_6_p_mem_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_6_p_mem___cinit__(((struct __pyx_obj_8slepc4py_5SLEPc__p_mem *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_6_p_mem___cinit__(struct __pyx_obj_8slepc4py_5SLEPc__p_mem *__pyx_v_self) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "SLEPc/allocate.pxi":14
 *     cdef void *buf
 *     def __cinit__(self):
 *         self.buf = NULL             # <<<<<<<<<<<<<<
 *     def __dealloc__(self):
 *         PyMem_Free(self.buf)
 */
  __pyx_v_self->buf = NULL;

  /* "SLEPc/allocate.pxi":13
 * cdef class _p_mem:
 *     cdef void *buf
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.buf = NULL
 *     def __dealloc__(self):
 */

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/allocate.pxi":15
 *     def __cinit__(self):
 *         self.buf = NULL
 *     def __dealloc__(self):             # <<<<<<<<<<<<<<
 *         PyMem_Free(self.buf)
 * 
 */

/* Python wrapper */
static void __pyx_pw_8slepc4py_5SLEPc_6_p_mem_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
static void __pyx_pw_8slepc4py_5SLEPc_6_p_mem_3__dealloc__(PyObject *__pyx_v_self) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
  __pyx_pf_8slepc4py_5SLEPc_6_p_mem_2__dealloc__(((struct __pyx_obj_8slepc4py_5SLEPc__p_mem *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

static void __pyx_pf_8slepc4py_5SLEPc_6_p_mem_2__dealloc__(struct __pyx_obj_8slepc4py_5SLEPc__p_mem *__pyx_v_self) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__dealloc__", 0);

  /* "SLEPc/allocate.pxi":16
 *         self.buf = NULL
 *     def __dealloc__(self):
 *         PyMem_Free(self.buf)             # <<<<<<<<<<<<<<
 * 
 * cdef inline object allocate(size_t n, void **buf):
 */
  PyMem_Free(__pyx_v_self->buf);

  /* "SLEPc/allocate.pxi":15
 *     def __cinit__(self):
 *         self.buf = NULL
 *     def __dealloc__(self):             # <<<<<<<<<<<<<<
 *         PyMem_Free(self.buf)
 * 
 */

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

/* "SLEPc/allocate.pxi":18
 *         PyMem_Free(self.buf)
 * 
 * cdef inline object allocate(size_t n, void **buf):             # <<<<<<<<<<<<<<
 *     cdef _p_mem ob = <_p_mem>_p_mem.__new__(_p_mem)
 *     ob.buf = PyMem_Malloc(<size_t>n)
 */

static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_allocate(size_t __pyx_v_n, void **__pyx_v_buf) {
  struct __pyx_obj_8slepc4py_5SLEPc__p_mem *__pyx_v_ob = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  void *__pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("allocate", 0);

  /* "SLEPc/allocate.pxi":19
 * 
 * cdef inline object allocate(size_t n, void **buf):
 *     cdef _p_mem ob = <_p_mem>_p_mem.__new__(_p_mem)             # <<<<<<<<<<<<<<
 *     ob.buf = PyMem_Malloc(<size_t>n)
 *     if ob.buf == NULL: raise MemoryError
 */
  __pyx_t_1 = ((PyObject *)__pyx_tp_new_8slepc4py_5SLEPc__p_mem(((PyTypeObject *)__pyx_ptype_8slepc4py_5SLEPc__p_mem), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 19, __pyx_L1_error)
  __Pyx_GOTREF(((PyObject *)__pyx_t_1));
  __pyx_t_2 = ((PyObject *)__pyx_t_1);
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_DECREF(((PyObject *)__pyx_t_1)); __pyx_t_1 = 0;
  __pyx_v_ob = ((struct __pyx_obj_8slepc4py_5SLEPc__p_mem *)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/allocate.pxi":20
 * cdef inline object allocate(size_t n, void **buf):
 *     cdef _p_mem ob = <_p_mem>_p_mem.__new__(_p_mem)
 *     ob.buf = PyMem_Malloc(<size_t>n)             # <<<<<<<<<<<<<<
 *     if ob.buf == NULL: raise MemoryError
 *     if buf != NULL: buf[0] = ob.buf
 */
  __pyx_v_ob->buf = PyMem_Malloc(((size_t)__pyx_v_n));

  /* "SLEPc/allocate.pxi":21
 *     cdef _p_mem ob = <_p_mem>_p_mem.__new__(_p_mem)
 *     ob.buf = PyMem_Malloc(<size_t>n)
 *     if ob.buf == NULL: raise MemoryError             # <<<<<<<<<<<<<<
 *     if buf != NULL: buf[0] = ob.buf
 *     return ob
 */
  __pyx_t_3 = ((__pyx_v_ob->buf == NULL) != 0);
  if (unlikely(__pyx_t_3)) {
    PyErr_NoMemory(); __PYX_ERR(1, 21, __pyx_L1_error)
  }

  /* "SLEPc/allocate.pxi":22
 *     ob.buf = PyMem_Malloc(<size_t>n)
 *     if ob.buf == NULL: raise MemoryError
 *     if buf != NULL: buf[0] = ob.buf             # <<<<<<<<<<<<<<
 *     return ob
 * 
 */
  __pyx_t_3 = ((__pyx_v_buf != NULL) != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_v_ob->buf;
    (__pyx_v_buf[0]) = __pyx_t_4;
  }

  /* "SLEPc/allocate.pxi":23
 *     if ob.buf == NULL: raise MemoryError
 *     if buf != NULL: buf[0] = ob.buf
 *     return ob             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ob));
  __pyx_r = ((PyObject *)__pyx_v_ob);
  goto __pyx_L0;

  /* "SLEPc/allocate.pxi":18
 *         PyMem_Free(self.buf)
 * 
 * cdef inline object allocate(size_t n, void **buf):             # <<<<<<<<<<<<<<
 *     cdef _p_mem ob = <_p_mem>_p_mem.__new__(_p_mem)
 *     ob.buf = PyMem_Malloc(<size_t>n)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.allocate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":65
 * from petsc4py.PETSc import Error as PetscError
 * 
 * cdef inline int SETERR(int ierr) with gil:             # <<<<<<<<<<<<<<
 *     if (<void*>PetscError) != NULL:
 *         PyErr_SetObject(PetscError, <long>ierr)
 */

static CYTHON_INLINE int __pyx_f_8slepc4py_5SLEPc_SETERR(int __pyx_v_ierr) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  #ifdef WITH_THREAD
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_RefNannySetupContext("SETERR", 0);

  /* "SLEPc/SLEPc.pyx":66
 * 
 * cdef inline int SETERR(int ierr) with gil:
 *     if (<void*>PetscError) != NULL:             # <<<<<<<<<<<<<<
 *         PyErr_SetObject(PetscError, <long>ierr)
 *     else:
 */
  __pyx_t_1 = ((((void *)__pyx_v_8slepc4py_5SLEPc_PetscError) != NULL) != 0);
  if (__pyx_t_1) {

    /* "SLEPc/SLEPc.pyx":67
 * cdef inline int SETERR(int ierr) with gil:
 *     if (<void*>PetscError) != NULL:
 *         PyErr_SetObject(PetscError, <long>ierr)             # <<<<<<<<<<<<<<
 *     else:
 *         PyErr_SetObject(<object>PyExc_RuntimeError, <long>ierr)
 */
    __pyx_t_2 = __pyx_v_8slepc4py_5SLEPc_PetscError;
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyInt_From_long(((long)__pyx_v_ierr)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 67, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    PyErr_SetObject(__pyx_t_2, __pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

    /* "SLEPc/SLEPc.pyx":66
 * 
 * cdef inline int SETERR(int ierr) with gil:
 *     if (<void*>PetscError) != NULL:             # <<<<<<<<<<<<<<
 *         PyErr_SetObject(PetscError, <long>ierr)
 *     else:
 */
    goto __pyx_L3;
  }

  /* "SLEPc/SLEPc.pyx":69
 *         PyErr_SetObject(PetscError, <long>ierr)
 *     else:
 *         PyErr_SetObject(<object>PyExc_RuntimeError, <long>ierr)             # <<<<<<<<<<<<<<
 *     return ierr
 * 
 */
  /*else*/ {
    __pyx_t_3 = ((PyObject *)PyExc_RuntimeError);
    __Pyx_INCREF(__pyx_t_3);
    __pyx_t_2 = __Pyx_PyInt_From_long(((long)__pyx_v_ierr)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 69, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    PyErr_SetObject(__pyx_t_3, __pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  }
  __pyx_L3:;

  /* "SLEPc/SLEPc.pyx":70
 *     else:
 *         PyErr_SetObject(<object>PyExc_RuntimeError, <long>ierr)
 *     return ierr             # <<<<<<<<<<<<<<
 * 
 * cdef inline int CHKERR(int ierr) nogil except -1:
 */
  __pyx_r = __pyx_v_ierr;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":65
 * from petsc4py.PETSc import Error as PetscError
 * 
 * cdef inline int SETERR(int ierr) with gil:             # <<<<<<<<<<<<<<
 *     if (<void*>PetscError) != NULL:
 *         PyErr_SetObject(PetscError, <long>ierr)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_WriteUnraisable("slepc4py.SLEPc.SETERR", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":72
 *     return ierr
 * 
 * cdef inline int CHKERR(int ierr) nogil except -1:             # <<<<<<<<<<<<<<
 *     if ierr == 0:
 *         return 0  # no error
 */

static CYTHON_INLINE int __pyx_f_8slepc4py_5SLEPc_CHKERR(int __pyx_v_ierr) {
  int __pyx_r;
  int __pyx_t_1;

  /* "SLEPc/SLEPc.pyx":73
 * 
 * cdef inline int CHKERR(int ierr) nogil except -1:
 *     if ierr == 0:             # <<<<<<<<<<<<<<
 *         return 0  # no error
 *     if ierr == PETSC_ERR_PYTHON:
 */
  __pyx_t_1 = ((__pyx_v_ierr == 0) != 0);
  if (__pyx_t_1) {

    /* "SLEPc/SLEPc.pyx":74
 * cdef inline int CHKERR(int ierr) nogil except -1:
 *     if ierr == 0:
 *         return 0  # no error             # <<<<<<<<<<<<<<
 *     if ierr == PETSC_ERR_PYTHON:
 *         return -1 # Python error
 */
    __pyx_r = 0;
    goto __pyx_L0;

    /* "SLEPc/SLEPc.pyx":73
 * 
 * cdef inline int CHKERR(int ierr) nogil except -1:
 *     if ierr == 0:             # <<<<<<<<<<<<<<
 *         return 0  # no error
 *     if ierr == PETSC_ERR_PYTHON:
 */
  }

  /* "SLEPc/SLEPc.pyx":75
 *     if ierr == 0:
 *         return 0  # no error
 *     if ierr == PETSC_ERR_PYTHON:             # <<<<<<<<<<<<<<
 *         return -1 # Python error
 *     SETERR(ierr)
 */
  __pyx_t_1 = ((__pyx_v_ierr == PETSC_ERR_PYTHON) != 0);
  if (__pyx_t_1) {

    /* "SLEPc/SLEPc.pyx":76
 *         return 0  # no error
 *     if ierr == PETSC_ERR_PYTHON:
 *         return -1 # Python error             # <<<<<<<<<<<<<<
 *     SETERR(ierr)
 *     return -1
 */
    __pyx_r = -1;
    goto __pyx_L0;

    /* "SLEPc/SLEPc.pyx":75
 *     if ierr == 0:
 *         return 0  # no error
 *     if ierr == PETSC_ERR_PYTHON:             # <<<<<<<<<<<<<<
 *         return -1 # Python error
 *     SETERR(ierr)
 */
  }

  /* "SLEPc/SLEPc.pyx":77
 *     if ierr == PETSC_ERR_PYTHON:
 *         return -1 # Python error
 *     SETERR(ierr)             # <<<<<<<<<<<<<<
 *     return -1
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_SETERR(__pyx_v_ierr));

  /* "SLEPc/SLEPc.pyx":78
 *         return -1 # Python error
 *     SETERR(ierr)
 *     return -1             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = -1;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":72
 *     return ierr
 * 
 * cdef inline int CHKERR(int ierr) nogil except -1:             # <<<<<<<<<<<<<<
 *     if ierr == 0:
 *         return 0  # no error
 */

  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":99
 *     PetscReal   PyPetscScalar_AsPetscComplexImag(object) except? <PetscReal>-1.0
 * 
 * cdef inline object toBool(PetscBool value):             # <<<<<<<<<<<<<<
 *     return True if value else False
 * cdef inline PetscBool asBool(object value) except? <PetscBool>0:
 */

static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_toBool(PetscBool __pyx_v_value) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("toBool", 0);

  /* "SLEPc/SLEPc.pyx":100
 * 
 * cdef inline object toBool(PetscBool value):
 *     return True if value else False             # <<<<<<<<<<<<<<
 * cdef inline PetscBool asBool(object value) except? <PetscBool>0:
 *     return PETSC_TRUE if value else PETSC_FALSE
 */
  __Pyx_XDECREF(__pyx_r);
  if (__pyx_v_value) {
    __Pyx_INCREF(Py_True);
    __pyx_t_1 = Py_True;
  } else {
    __Pyx_INCREF(Py_False);
    __pyx_t_1 = Py_False;
  }
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":99
 *     PetscReal   PyPetscScalar_AsPetscComplexImag(object) except? <PetscReal>-1.0
 * 
 * cdef inline object toBool(PetscBool value):             # <<<<<<<<<<<<<<
 *     return True if value else False
 * cdef inline PetscBool asBool(object value) except? <PetscBool>0:
 */

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":101
 * cdef inline object toBool(PetscBool value):
 *     return True if value else False
 * cdef inline PetscBool asBool(object value) except? <PetscBool>0:             # <<<<<<<<<<<<<<
 *     return PETSC_TRUE if value else PETSC_FALSE
 * 
 */

static CYTHON_INLINE PetscBool __pyx_f_8slepc4py_5SLEPc_asBool(PyObject *__pyx_v_value) {
  PetscBool __pyx_r;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("asBool", 0);

  /* "SLEPc/SLEPc.pyx":102
 *     return True if value else False
 * cdef inline PetscBool asBool(object value) except? <PetscBool>0:
 *     return PETSC_TRUE if value else PETSC_FALSE             # <<<<<<<<<<<<<<
 * 
 * cdef inline object toInt(PetscInt value):
 */
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(4, 102, __pyx_L1_error)
  if (__pyx_t_2) {
    __pyx_t_1 = PETSC_TRUE;
  } else {
    __pyx_t_1 = PETSC_FALSE;
  }
  __pyx_r = __pyx_t_1;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":101
 * cdef inline object toBool(PetscBool value):
 *     return True if value else False
 * cdef inline PetscBool asBool(object value) except? <PetscBool>0:             # <<<<<<<<<<<<<<
 *     return PETSC_TRUE if value else PETSC_FALSE
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.asBool", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = ((PetscBool)0);
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":104
 *     return PETSC_TRUE if value else PETSC_FALSE
 * 
 * cdef inline object toInt(PetscInt value):             # <<<<<<<<<<<<<<
 *     return value
 * cdef inline PetscInt asInt(object value) except? -1:
 */

static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_toInt(PetscInt __pyx_v_value) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("toInt", 0);

  /* "SLEPc/SLEPc.pyx":105
 * 
 * cdef inline object toInt(PetscInt value):
 *     return value             # <<<<<<<<<<<<<<
 * cdef inline PetscInt asInt(object value) except? -1:
 *     return value
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyInt_From_PetscInt(__pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 105, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":104
 *     return PETSC_TRUE if value else PETSC_FALSE
 * 
 * cdef inline object toInt(PetscInt value):             # <<<<<<<<<<<<<<
 *     return value
 * cdef inline PetscInt asInt(object value) except? -1:
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.toInt", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":106
 * cdef inline object toInt(PetscInt value):
 *     return value
 * cdef inline PetscInt asInt(object value) except? -1:             # <<<<<<<<<<<<<<
 *     return value
 * 
 */

static CYTHON_INLINE PetscInt __pyx_f_8slepc4py_5SLEPc_asInt(PyObject *__pyx_v_value) {
  PetscInt __pyx_r;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("asInt", 0);

  /* "SLEPc/SLEPc.pyx":107
 *     return value
 * cdef inline PetscInt asInt(object value) except? -1:
 *     return value             # <<<<<<<<<<<<<<
 * 
 * cdef inline object toReal(PetscReal value):
 */
  __pyx_t_1 = __Pyx_PyInt_As_PetscInt(__pyx_v_value); if (unlikely((__pyx_t_1 == ((PetscInt)-1)) && PyErr_Occurred())) __PYX_ERR(4, 107, __pyx_L1_error)
  __pyx_r = __pyx_t_1;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":106
 * cdef inline object toInt(PetscInt value):
 *     return value
 * cdef inline PetscInt asInt(object value) except? -1:             # <<<<<<<<<<<<<<
 *     return value
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.asInt", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1L;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":109
 *     return value
 * 
 * cdef inline object toReal(PetscReal value):             # <<<<<<<<<<<<<<
 *     return value
 * cdef inline PetscReal asReal(object value) except? -1:
 */

static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_toReal(PetscReal __pyx_v_value) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("toReal", 0);

  /* "SLEPc/SLEPc.pyx":110
 * 
 * cdef inline object toReal(PetscReal value):
 *     return value             # <<<<<<<<<<<<<<
 * cdef inline PetscReal asReal(object value) except? -1:
 *     return value
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 110, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":109
 *     return value
 * 
 * cdef inline object toReal(PetscReal value):             # <<<<<<<<<<<<<<
 *     return value
 * cdef inline PetscReal asReal(object value) except? -1:
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.toReal", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":111
 * cdef inline object toReal(PetscReal value):
 *     return value
 * cdef inline PetscReal asReal(object value) except? -1:             # <<<<<<<<<<<<<<
 *     return value
 * 
 */

static CYTHON_INLINE PetscReal __pyx_f_8slepc4py_5SLEPc_asReal(PyObject *__pyx_v_value) {
  PetscReal __pyx_r;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("asReal", 0);

  /* "SLEPc/SLEPc.pyx":112
 *     return value
 * cdef inline PetscReal asReal(object value) except? -1:
 *     return value             # <<<<<<<<<<<<<<
 * 
 * cdef inline object toScalar(PetscScalar value):
 */
  __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == ((PetscReal)-1)) && PyErr_Occurred())) __PYX_ERR(4, 112, __pyx_L1_error)
  __pyx_r = __pyx_t_1;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":111
 * cdef inline object toReal(PetscReal value):
 *     return value
 * cdef inline PetscReal asReal(object value) except? -1:             # <<<<<<<<<<<<<<
 *     return value
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.asReal", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1.0;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":114
 *     return value
 * 
 * cdef inline object toScalar(PetscScalar value):             # <<<<<<<<<<<<<<
 *     return PyPetscScalar_FromPetscScalar(value)
 * cdef inline PetscScalar asScalar(object value) except? <PetscScalar>-1.0:
 */

static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_toScalar(PetscScalar __pyx_v_value) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("toScalar", 0);

  /* "SLEPc/SLEPc.pyx":115
 * 
 * cdef inline object toScalar(PetscScalar value):
 *     return PyPetscScalar_FromPetscScalar(value)             # <<<<<<<<<<<<<<
 * cdef inline PetscScalar asScalar(object value) except? <PetscScalar>-1.0:
 *     return PyPetscScalar_AsPetscScalar(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyPetscScalar_FromPetscScalar(__pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 115, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":114
 *     return value
 * 
 * cdef inline object toScalar(PetscScalar value):             # <<<<<<<<<<<<<<
 *     return PyPetscScalar_FromPetscScalar(value)
 * cdef inline PetscScalar asScalar(object value) except? <PetscScalar>-1.0:
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.toScalar", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":116
 * cdef inline object toScalar(PetscScalar value):
 *     return PyPetscScalar_FromPetscScalar(value)
 * cdef inline PetscScalar asScalar(object value) except? <PetscScalar>-1.0:             # <<<<<<<<<<<<<<
 *     return PyPetscScalar_AsPetscScalar(value)
 * 
 */

static CYTHON_INLINE PetscScalar __pyx_f_8slepc4py_5SLEPc_asScalar(PyObject *__pyx_v_value) {
  PetscScalar __pyx_r;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("asScalar", 0);

  /* "SLEPc/SLEPc.pyx":117
 *     return PyPetscScalar_FromPetscScalar(value)
 * cdef inline PetscScalar asScalar(object value) except? <PetscScalar>-1.0:
 *     return PyPetscScalar_AsPetscScalar(value)             # <<<<<<<<<<<<<<
 * 
 * cdef inline object toComplex(PetscScalar rvalue, PetscScalar ivalue):
 */
  __pyx_t_1 = PyPetscScalar_AsPetscScalar(__pyx_v_value); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(4, 117, __pyx_L1_error)
  __pyx_r = __pyx_t_1;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":116
 * cdef inline object toScalar(PetscScalar value):
 *     return PyPetscScalar_FromPetscScalar(value)
 * cdef inline PetscScalar asScalar(object value) except? <PetscScalar>-1.0:             # <<<<<<<<<<<<<<
 *     return PyPetscScalar_AsPetscScalar(value)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.asScalar", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = ((PetscScalar)(-1.0));
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":119
 *     return PyPetscScalar_AsPetscScalar(value)
 * 
 * cdef inline object toComplex(PetscScalar rvalue, PetscScalar ivalue):             # <<<<<<<<<<<<<<
 *     return complex(toScalar(rvalue),toScalar(ivalue))
 * cdef inline PetscReal asComplexReal(object value) except? <PetscReal>-1.0:
 */

static CYTHON_INLINE PyObject *__pyx_f_8slepc4py_5SLEPc_toComplex(PetscScalar __pyx_v_rvalue, PetscScalar __pyx_v_ivalue) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("toComplex", 0);

  /* "SLEPc/SLEPc.pyx":120
 * 
 * cdef inline object toComplex(PetscScalar rvalue, PetscScalar ivalue):
 *     return complex(toScalar(rvalue),toScalar(ivalue))             # <<<<<<<<<<<<<<
 * cdef inline PetscReal asComplexReal(object value) except? <PetscReal>-1.0:
 *     return PyPetscScalar_AsPetscComplexReal(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_rvalue); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 120, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_ivalue); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 120, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 120, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
  __pyx_t_1 = 0;
  __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyComplex_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 120, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":119
 *     return PyPetscScalar_AsPetscScalar(value)
 * 
 * cdef inline object toComplex(PetscScalar rvalue, PetscScalar ivalue):             # <<<<<<<<<<<<<<
 *     return complex(toScalar(rvalue),toScalar(ivalue))
 * cdef inline PetscReal asComplexReal(object value) except? <PetscReal>-1.0:
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.toComplex", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":121
 * cdef inline object toComplex(PetscScalar rvalue, PetscScalar ivalue):
 *     return complex(toScalar(rvalue),toScalar(ivalue))
 * cdef inline PetscReal asComplexReal(object value) except? <PetscReal>-1.0:             # <<<<<<<<<<<<<<
 *     return PyPetscScalar_AsPetscComplexReal(value)
 * cdef inline PetscReal asComplexImag(object value) except? <PetscReal>-1.0:
 */

static CYTHON_INLINE PetscReal __pyx_f_8slepc4py_5SLEPc_asComplexReal(PyObject *__pyx_v_value) {
  PetscReal __pyx_r;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("asComplexReal", 0);

  /* "SLEPc/SLEPc.pyx":122
 *     return complex(toScalar(rvalue),toScalar(ivalue))
 * cdef inline PetscReal asComplexReal(object value) except? <PetscReal>-1.0:
 *     return PyPetscScalar_AsPetscComplexReal(value)             # <<<<<<<<<<<<<<
 * cdef inline PetscReal asComplexImag(object value) except? <PetscReal>-1.0:
 *     return PyPetscScalar_AsPetscComplexImag(value)
 */
  __pyx_t_1 = PyPetscScalar_AsPetscComplexReal(__pyx_v_value); if (unlikely(__pyx_t_1 == ((PetscReal)((PetscReal)(-1.0))) && PyErr_Occurred())) __PYX_ERR(4, 122, __pyx_L1_error)
  __pyx_r = __pyx_t_1;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":121
 * cdef inline object toComplex(PetscScalar rvalue, PetscScalar ivalue):
 *     return complex(toScalar(rvalue),toScalar(ivalue))
 * cdef inline PetscReal asComplexReal(object value) except? <PetscReal>-1.0:             # <<<<<<<<<<<<<<
 *     return PyPetscScalar_AsPetscComplexReal(value)
 * cdef inline PetscReal asComplexImag(object value) except? <PetscReal>-1.0:
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.asComplexReal", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = ((PetscReal)(-1.0));
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":123
 * cdef inline PetscReal asComplexReal(object value) except? <PetscReal>-1.0:
 *     return PyPetscScalar_AsPetscComplexReal(value)
 * cdef inline PetscReal asComplexImag(object value) except? <PetscReal>-1.0:             # <<<<<<<<<<<<<<
 *     return PyPetscScalar_AsPetscComplexImag(value)
 * 
 */

static CYTHON_INLINE PetscReal __pyx_f_8slepc4py_5SLEPc_asComplexImag(PyObject *__pyx_v_value) {
  PetscReal __pyx_r;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("asComplexImag", 0);

  /* "SLEPc/SLEPc.pyx":124
 *     return PyPetscScalar_AsPetscComplexReal(value)
 * cdef inline PetscReal asComplexImag(object value) except? <PetscReal>-1.0:
 *     return PyPetscScalar_AsPetscComplexImag(value)             # <<<<<<<<<<<<<<
 * 
 * # --------------------------------------------------------------------
 */
  __pyx_t_1 = PyPetscScalar_AsPetscComplexImag(__pyx_v_value); if (unlikely(__pyx_t_1 == ((PetscReal)((PetscReal)(-1.0))) && PyErr_Occurred())) __PYX_ERR(4, 124, __pyx_L1_error)
  __pyx_r = __pyx_t_1;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":123
 * cdef inline PetscReal asComplexReal(object value) except? <PetscReal>-1.0:
 *     return PyPetscScalar_AsPetscComplexReal(value)
 * cdef inline PetscReal asComplexImag(object value) except? <PetscReal>-1.0:             # <<<<<<<<<<<<<<
 *     return PyPetscScalar_AsPetscComplexImag(value)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.asComplexImag", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = ((PetscReal)(-1.0));
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":68
 * # --------------------------------------------------------------------
 * 
 * cdef inline ndarray asarray(object ob):             # <<<<<<<<<<<<<<
 *     return PyArray_FROM_O(ob)
 * 
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_asarray(PyObject *__pyx_v_ob) {
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("asarray", 0);

  /* "include/arraynpy.pxi":69
 * 
 * cdef inline ndarray asarray(object ob):
 *     return PyArray_FROM_O(ob)             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray arange(start, stop, stride):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __pyx_t_1 = ((PyObject *)PyArray_FROM_O(__pyx_v_ob)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 69, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":68
 * # --------------------------------------------------------------------
 * 
 * cdef inline ndarray asarray(object ob):             # <<<<<<<<<<<<<<
 *     return PyArray_FROM_O(ob)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.asarray", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":71
 *     return PyArray_FROM_O(ob)
 * 
 * cdef inline ndarray arange(start, stop, stride):             # <<<<<<<<<<<<<<
 *     cdef dtype descr = <dtype> PyArray_DescrFromType(NPY_PETSC_INT)
 *     return PyArray_ArangeObj(start, stop, stride, descr)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_arange(PyObject *__pyx_v_start, PyObject *__pyx_v_stop, PyObject *__pyx_v_stride) {
  PyArray_Descr *__pyx_v_descr = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("arange", 0);

  /* "include/arraynpy.pxi":72
 * 
 * cdef inline ndarray arange(start, stop, stride):
 *     cdef dtype descr = <dtype> PyArray_DescrFromType(NPY_PETSC_INT)             # <<<<<<<<<<<<<<
 *     return PyArray_ArangeObj(start, stop, stride, descr)
 * 
 */
  __pyx_t_1 = ((PyObject *)PyArray_DescrFromType(NPY_PETSC_INT)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 72, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_t_1;
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_descr = ((PyArray_Descr *)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "include/arraynpy.pxi":73
 * cdef inline ndarray arange(start, stop, stride):
 *     cdef dtype descr = <dtype> PyArray_DescrFromType(NPY_PETSC_INT)
 *     return PyArray_ArangeObj(start, stop, stride, descr)             # <<<<<<<<<<<<<<
 * 
 * # --------------------------------------------------------------------
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __pyx_t_2 = ((PyObject *)PyArray_ArangeObj(__pyx_v_start, __pyx_v_stop, __pyx_v_stride, __pyx_v_descr)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = ((PyArrayObject *)__pyx_t_2);
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":71
 *     return PyArray_FROM_O(ob)
 * 
 * cdef inline ndarray arange(start, stop, stride):             # <<<<<<<<<<<<<<
 *     cdef dtype descr = <dtype> PyArray_DescrFromType(NPY_PETSC_INT)
 *     return PyArray_ArangeObj(start, stop, stride, descr)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.arange", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_descr);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":77
 * # --------------------------------------------------------------------
 * 
 * cdef inline ndarray empty_i(PetscInt size):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_INT, 0)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_empty_i(PetscInt __pyx_v_size) {
  npy_intp __pyx_v_s;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("empty_i", 0);

  /* "include/arraynpy.pxi":78
 * 
 * cdef inline ndarray empty_i(PetscInt size):
 *     cdef npy_intp s = <npy_intp> size             # <<<<<<<<<<<<<<
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_INT, 0)
 * 
 */
  __pyx_v_s = ((npy_intp)__pyx_v_size);

  /* "include/arraynpy.pxi":79
 * cdef inline ndarray empty_i(PetscInt size):
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_INT, 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray empty_r(PetscInt size):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_s), NPY_PETSC_INT, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 79, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":77
 * # --------------------------------------------------------------------
 * 
 * cdef inline ndarray empty_i(PetscInt size):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_INT, 0)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.empty_i", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":81
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_INT, 0)
 * 
 * cdef inline ndarray empty_r(PetscInt size):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_REAL, 0)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_empty_r(PetscInt __pyx_v_size) {
  npy_intp __pyx_v_s;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("empty_r", 0);

  /* "include/arraynpy.pxi":82
 * 
 * cdef inline ndarray empty_r(PetscInt size):
 *     cdef npy_intp s = <npy_intp> size             # <<<<<<<<<<<<<<
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_REAL, 0)
 * 
 */
  __pyx_v_s = ((npy_intp)__pyx_v_size);

  /* "include/arraynpy.pxi":83
 * cdef inline ndarray empty_r(PetscInt size):
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_REAL, 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray empty_s(PetscInt size):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_s), NPY_PETSC_REAL, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 83, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":81
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_INT, 0)
 * 
 * cdef inline ndarray empty_r(PetscInt size):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_REAL, 0)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.empty_r", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":85
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_REAL, 0)
 * 
 * cdef inline ndarray empty_s(PetscInt size):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_SCALAR, 0)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_empty_s(PetscInt __pyx_v_size) {
  npy_intp __pyx_v_s;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("empty_s", 0);

  /* "include/arraynpy.pxi":86
 * 
 * cdef inline ndarray empty_s(PetscInt size):
 *     cdef npy_intp s = <npy_intp> size             # <<<<<<<<<<<<<<
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_SCALAR, 0)
 * 
 */
  __pyx_v_s = ((npy_intp)__pyx_v_size);

  /* "include/arraynpy.pxi":87
 * cdef inline ndarray empty_s(PetscInt size):
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_SCALAR, 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray empty_c(PetscInt size):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_s), NPY_PETSC_SCALAR, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 87, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":85
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_REAL, 0)
 * 
 * cdef inline ndarray empty_s(PetscInt size):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_SCALAR, 0)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.empty_s", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":89
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_SCALAR, 0)
 * 
 * cdef inline ndarray empty_c(PetscInt size):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_COMPLEX, 0)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_empty_c(PetscInt __pyx_v_size) {
  npy_intp __pyx_v_s;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("empty_c", 0);

  /* "include/arraynpy.pxi":90
 * 
 * cdef inline ndarray empty_c(PetscInt size):
 *     cdef npy_intp s = <npy_intp> size             # <<<<<<<<<<<<<<
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_COMPLEX, 0)
 * 
 */
  __pyx_v_s = ((npy_intp)__pyx_v_size);

  /* "include/arraynpy.pxi":91
 * cdef inline ndarray empty_c(PetscInt size):
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_COMPLEX, 0)             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray empty_p(PetscInt size):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_s), NPY_PETSC_COMPLEX, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 91, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":89
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_SCALAR, 0)
 * 
 * cdef inline ndarray empty_c(PetscInt size):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_COMPLEX, 0)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.empty_c", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":93
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_COMPLEX, 0)
 * 
 * cdef inline ndarray empty_p(PetscInt size):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_INTP, 0)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_empty_p(PetscInt __pyx_v_size) {
  npy_intp __pyx_v_s;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("empty_p", 0);

  /* "include/arraynpy.pxi":94
 * 
 * cdef inline ndarray empty_p(PetscInt size):
 *     cdef npy_intp s = <npy_intp> size             # <<<<<<<<<<<<<<
 *     return PyArray_EMPTY(1, &s, NPY_INTP, 0)
 * 
 */
  __pyx_v_s = ((npy_intp)__pyx_v_size);

  /* "include/arraynpy.pxi":95
 * cdef inline ndarray empty_p(PetscInt size):
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_INTP, 0)             # <<<<<<<<<<<<<<
 * 
 * # --------------------------------------------------------------------
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_s), NPY_INTP, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 95, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":93
 *     return PyArray_EMPTY(1, &s, NPY_PETSC_COMPLEX, 0)
 * 
 * cdef inline ndarray empty_p(PetscInt size):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     return PyArray_EMPTY(1, &s, NPY_INTP, 0)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.empty_p", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":99
 * # --------------------------------------------------------------------
 * 
 * cdef inline ndarray array_i(PetscInt size, const PetscInt* data):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_INT, 0)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_array_i(PetscInt __pyx_v_size, PetscInt const *__pyx_v_data) {
  npy_intp __pyx_v_s;
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("array_i", 0);

  /* "include/arraynpy.pxi":100
 * 
 * cdef inline ndarray array_i(PetscInt size, const PetscInt* data):
 *     cdef npy_intp s = <npy_intp> size             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_INT, 0)
 *     if data != NULL:
 */
  __pyx_v_s = ((npy_intp)__pyx_v_size);

  /* "include/arraynpy.pxi":101
 * cdef inline ndarray array_i(PetscInt size, const PetscInt* data):
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_INT, 0)             # <<<<<<<<<<<<<<
 *     if data != NULL:
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscInt))
 */
  __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_s), NPY_PETSC_INT, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":102
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_INT, 0)
 *     if data != NULL:             # <<<<<<<<<<<<<<
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscInt))
 *     return ary
 */
  __pyx_t_2 = ((__pyx_v_data != NULL) != 0);
  if (__pyx_t_2) {

    /* "include/arraynpy.pxi":103
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_INT, 0)
 *     if data != NULL:
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscInt))             # <<<<<<<<<<<<<<
 *     return ary
 * 
 */
    (void)(memcpy(PyArray_DATA(__pyx_v_ary), __pyx_v_data, (((size_t)__pyx_v_size) * (sizeof(PetscInt)))));

    /* "include/arraynpy.pxi":102
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_INT, 0)
 *     if data != NULL:             # <<<<<<<<<<<<<<
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscInt))
 *     return ary
 */
  }

  /* "include/arraynpy.pxi":104
 *     if data != NULL:
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscInt))
 *     return ary             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray array_r(PetscInt size, const PetscReal* data):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ary));
  __pyx_r = __pyx_v_ary;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":99
 * # --------------------------------------------------------------------
 * 
 * cdef inline ndarray array_i(PetscInt size, const PetscInt* data):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_INT, 0)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.array_i", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":106
 *     return ary
 * 
 * cdef inline ndarray array_r(PetscInt size, const PetscReal* data):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_REAL, 0)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_array_r(PetscInt __pyx_v_size, PetscReal const *__pyx_v_data) {
  npy_intp __pyx_v_s;
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("array_r", 0);

  /* "include/arraynpy.pxi":107
 * 
 * cdef inline ndarray array_r(PetscInt size, const PetscReal* data):
 *     cdef npy_intp s = <npy_intp> size             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_REAL, 0)
 *     if data != NULL:
 */
  __pyx_v_s = ((npy_intp)__pyx_v_size);

  /* "include/arraynpy.pxi":108
 * cdef inline ndarray array_r(PetscInt size, const PetscReal* data):
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_REAL, 0)             # <<<<<<<<<<<<<<
 *     if data != NULL:
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscReal))
 */
  __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_s), NPY_PETSC_REAL, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 108, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":109
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_REAL, 0)
 *     if data != NULL:             # <<<<<<<<<<<<<<
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscReal))
 *     return ary
 */
  __pyx_t_2 = ((__pyx_v_data != NULL) != 0);
  if (__pyx_t_2) {

    /* "include/arraynpy.pxi":110
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_REAL, 0)
 *     if data != NULL:
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscReal))             # <<<<<<<<<<<<<<
 *     return ary
 * 
 */
    (void)(memcpy(PyArray_DATA(__pyx_v_ary), __pyx_v_data, (((size_t)__pyx_v_size) * (sizeof(PetscReal)))));

    /* "include/arraynpy.pxi":109
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_REAL, 0)
 *     if data != NULL:             # <<<<<<<<<<<<<<
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscReal))
 *     return ary
 */
  }

  /* "include/arraynpy.pxi":111
 *     if data != NULL:
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscReal))
 *     return ary             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray array_b(PetscInt size, const PetscBool* data):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ary));
  __pyx_r = __pyx_v_ary;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":106
 *     return ary
 * 
 * cdef inline ndarray array_r(PetscInt size, const PetscReal* data):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_REAL, 0)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.array_r", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":113
 *     return ary
 * 
 * cdef inline ndarray array_b(PetscInt size, const PetscBool* data):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_BOOL, 0)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_array_b(PetscInt __pyx_v_size, PetscBool const *__pyx_v_data) {
  npy_intp __pyx_v_s;
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("array_b", 0);

  /* "include/arraynpy.pxi":114
 * 
 * cdef inline ndarray array_b(PetscInt size, const PetscBool* data):
 *     cdef npy_intp s = <npy_intp> size             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_BOOL, 0)
 *     if data != NULL:
 */
  __pyx_v_s = ((npy_intp)__pyx_v_size);

  /* "include/arraynpy.pxi":115
 * cdef inline ndarray array_b(PetscInt size, const PetscBool* data):
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_BOOL, 0)             # <<<<<<<<<<<<<<
 *     if data != NULL:
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscBool))
 */
  __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_s), NPY_PETSC_BOOL, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 115, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":116
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_BOOL, 0)
 *     if data != NULL:             # <<<<<<<<<<<<<<
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscBool))
 *     return ary
 */
  __pyx_t_2 = ((__pyx_v_data != NULL) != 0);
  if (__pyx_t_2) {

    /* "include/arraynpy.pxi":117
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_BOOL, 0)
 *     if data != NULL:
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscBool))             # <<<<<<<<<<<<<<
 *     return ary
 * 
 */
    (void)(memcpy(PyArray_DATA(__pyx_v_ary), __pyx_v_data, (((size_t)__pyx_v_size) * (sizeof(PetscBool)))));

    /* "include/arraynpy.pxi":116
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_BOOL, 0)
 *     if data != NULL:             # <<<<<<<<<<<<<<
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscBool))
 *     return ary
 */
  }

  /* "include/arraynpy.pxi":118
 *     if data != NULL:
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscBool))
 *     return ary             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray array_s(PetscInt size, const PetscScalar* data):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ary));
  __pyx_r = __pyx_v_ary;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":113
 *     return ary
 * 
 * cdef inline ndarray array_b(PetscInt size, const PetscBool* data):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_BOOL, 0)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.array_b", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":120
 *     return ary
 * 
 * cdef inline ndarray array_s(PetscInt size, const PetscScalar* data):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_SCALAR, 0)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_array_s(PetscInt __pyx_v_size, PetscScalar const *__pyx_v_data) {
  npy_intp __pyx_v_s;
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("array_s", 0);

  /* "include/arraynpy.pxi":121
 * 
 * cdef inline ndarray array_s(PetscInt size, const PetscScalar* data):
 *     cdef npy_intp s = <npy_intp> size             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_SCALAR, 0)
 *     if data != NULL:
 */
  __pyx_v_s = ((npy_intp)__pyx_v_size);

  /* "include/arraynpy.pxi":122
 * cdef inline ndarray array_s(PetscInt size, const PetscScalar* data):
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_SCALAR, 0)             # <<<<<<<<<<<<<<
 *     if data != NULL:
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscScalar))
 */
  __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_s), NPY_PETSC_SCALAR, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 122, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":123
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_SCALAR, 0)
 *     if data != NULL:             # <<<<<<<<<<<<<<
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscScalar))
 *     return ary
 */
  __pyx_t_2 = ((__pyx_v_data != NULL) != 0);
  if (__pyx_t_2) {

    /* "include/arraynpy.pxi":124
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_SCALAR, 0)
 *     if data != NULL:
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscScalar))             # <<<<<<<<<<<<<<
 *     return ary
 * 
 */
    (void)(memcpy(PyArray_DATA(__pyx_v_ary), __pyx_v_data, (((size_t)__pyx_v_size) * (sizeof(PetscScalar)))));

    /* "include/arraynpy.pxi":123
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_SCALAR, 0)
 *     if data != NULL:             # <<<<<<<<<<<<<<
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscScalar))
 *     return ary
 */
  }

  /* "include/arraynpy.pxi":125
 *     if data != NULL:
 *         memcpy(PyArray_DATA(ary), data, <size_t>size*sizeof(PetscScalar))
 *     return ary             # <<<<<<<<<<<<<<
 * 
 * # --------------------------------------------------------------------
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ary));
  __pyx_r = __pyx_v_ary;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":120
 *     return ary
 * 
 * cdef inline ndarray array_s(PetscInt size, const PetscScalar* data):             # <<<<<<<<<<<<<<
 *     cdef npy_intp s = <npy_intp> size
 *     cdef ndarray ary = PyArray_EMPTY(1, &s, NPY_PETSC_SCALAR, 0)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.array_s", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":129
 * # --------------------------------------------------------------------
 * 
 * cdef inline ndarray iarray(object ob, int typenum):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = PyArray_FROM_OTF(
 *         ob, typenum, NPY_ARRAY_ALIGNED|NPY_ARRAY_NOTSWAPPED)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_iarray(PyObject *__pyx_v_ob, int __pyx_v_typenum) {
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("iarray", 0);

  /* "include/arraynpy.pxi":130
 * 
 * cdef inline ndarray iarray(object ob, int typenum):
 *     cdef ndarray ary = PyArray_FROM_OTF(             # <<<<<<<<<<<<<<
 *         ob, typenum, NPY_ARRAY_ALIGNED|NPY_ARRAY_NOTSWAPPED)
 *     if PyArray_ISCONTIGUOUS(ary): return ary
 */
  __pyx_t_1 = ((PyObject *)PyArray_FROM_OTF(__pyx_v_ob, __pyx_v_typenum, (NPY_ARRAY_ALIGNED | NPY_ARRAY_NOTSWAPPED))); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":132
 *     cdef ndarray ary = PyArray_FROM_OTF(
 *         ob, typenum, NPY_ARRAY_ALIGNED|NPY_ARRAY_NOTSWAPPED)
 *     if PyArray_ISCONTIGUOUS(ary): return ary             # <<<<<<<<<<<<<<
 *     if PyArray_ISFORTRAN(ary):    return ary
 *     return PyArray_Copy(ary)
 */
  __pyx_t_2 = (PyArray_ISCONTIGUOUS(__pyx_v_ary) != 0);
  if (__pyx_t_2) {
    __Pyx_XDECREF(((PyObject *)__pyx_r));
    __Pyx_INCREF(((PyObject *)__pyx_v_ary));
    __pyx_r = __pyx_v_ary;
    goto __pyx_L0;
  }

  /* "include/arraynpy.pxi":133
 *         ob, typenum, NPY_ARRAY_ALIGNED|NPY_ARRAY_NOTSWAPPED)
 *     if PyArray_ISCONTIGUOUS(ary): return ary
 *     if PyArray_ISFORTRAN(ary):    return ary             # <<<<<<<<<<<<<<
 *     return PyArray_Copy(ary)
 * 
 */
  __pyx_t_2 = (PyArray_ISFORTRAN(__pyx_v_ary) != 0);
  if (__pyx_t_2) {
    __Pyx_XDECREF(((PyObject *)__pyx_r));
    __Pyx_INCREF(((PyObject *)__pyx_v_ary));
    __pyx_r = __pyx_v_ary;
    goto __pyx_L0;
  }

  /* "include/arraynpy.pxi":134
 *     if PyArray_ISCONTIGUOUS(ary): return ary
 *     if PyArray_ISFORTRAN(ary):    return ary
 *     return PyArray_Copy(ary)             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray iarray_i(object ob, PetscInt* size, PetscInt** data):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __pyx_t_1 = ((PyObject *)PyArray_Copy(__pyx_v_ary)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 134, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":129
 * # --------------------------------------------------------------------
 * 
 * cdef inline ndarray iarray(object ob, int typenum):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = PyArray_FROM_OTF(
 *         ob, typenum, NPY_ARRAY_ALIGNED|NPY_ARRAY_NOTSWAPPED)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.iarray", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":136
 *     return PyArray_Copy(ary)
 * 
 * cdef inline ndarray iarray_i(object ob, PetscInt* size, PetscInt** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_INT)
 *     if size != NULL: size[0] = <PetscInt>  PyArray_SIZE(ary)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_iarray_i(PyObject *__pyx_v_ob, PetscInt *__pyx_v_size, PetscInt **__pyx_v_data) {
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("iarray_i", 0);

  /* "include/arraynpy.pxi":137
 * 
 * cdef inline ndarray iarray_i(object ob, PetscInt* size, PetscInt** data):
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_INT)             # <<<<<<<<<<<<<<
 *     if size != NULL: size[0] = <PetscInt>  PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscInt*> PyArray_DATA(ary)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_iarray(__pyx_v_ob, NPY_PETSC_INT)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 137, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":138
 * cdef inline ndarray iarray_i(object ob, PetscInt* size, PetscInt** data):
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_INT)
 *     if size != NULL: size[0] = <PetscInt>  PyArray_SIZE(ary)             # <<<<<<<<<<<<<<
 *     if data != NULL: data[0] = <PetscInt*> PyArray_DATA(ary)
 *     return ary
 */
  __pyx_t_2 = ((__pyx_v_size != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_size[0]) = ((PetscInt)PyArray_SIZE(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":139
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_INT)
 *     if size != NULL: size[0] = <PetscInt>  PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscInt*> PyArray_DATA(ary)             # <<<<<<<<<<<<<<
 *     return ary
 * 
 */
  __pyx_t_2 = ((__pyx_v_data != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_data[0]) = ((PetscInt *)PyArray_DATA(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":140
 *     if size != NULL: size[0] = <PetscInt>  PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscInt*> PyArray_DATA(ary)
 *     return ary             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray iarray_r(object ob, PetscInt* size, PetscReal** data):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ary));
  __pyx_r = __pyx_v_ary;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":136
 *     return PyArray_Copy(ary)
 * 
 * cdef inline ndarray iarray_i(object ob, PetscInt* size, PetscInt** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_INT)
 *     if size != NULL: size[0] = <PetscInt>  PyArray_SIZE(ary)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.iarray_i", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":142
 *     return ary
 * 
 * cdef inline ndarray iarray_r(object ob, PetscInt* size, PetscReal** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_REAL)
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_iarray_r(PyObject *__pyx_v_ob, PetscInt *__pyx_v_size, PetscReal **__pyx_v_data) {
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("iarray_r", 0);

  /* "include/arraynpy.pxi":143
 * 
 * cdef inline ndarray iarray_r(object ob, PetscInt* size, PetscReal** data):
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_REAL)             # <<<<<<<<<<<<<<
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscReal*> PyArray_DATA(ary)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_iarray(__pyx_v_ob, NPY_PETSC_REAL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 143, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":144
 * cdef inline ndarray iarray_r(object ob, PetscInt* size, PetscReal** data):
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_REAL)
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)             # <<<<<<<<<<<<<<
 *     if data != NULL: data[0] = <PetscReal*> PyArray_DATA(ary)
 *     return ary
 */
  __pyx_t_2 = ((__pyx_v_size != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_size[0]) = ((PetscInt)PyArray_SIZE(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":145
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_REAL)
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscReal*> PyArray_DATA(ary)             # <<<<<<<<<<<<<<
 *     return ary
 * 
 */
  __pyx_t_2 = ((__pyx_v_data != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_data[0]) = ((PetscReal *)PyArray_DATA(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":146
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscReal*> PyArray_DATA(ary)
 *     return ary             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray iarray_b(object ob, PetscInt* size, PetscBool** data):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ary));
  __pyx_r = __pyx_v_ary;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":142
 *     return ary
 * 
 * cdef inline ndarray iarray_r(object ob, PetscInt* size, PetscReal** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_REAL)
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.iarray_r", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":148
 *     return ary
 * 
 * cdef inline ndarray iarray_b(object ob, PetscInt* size, PetscBool** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_BOOL)
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_iarray_b(PyObject *__pyx_v_ob, PetscInt *__pyx_v_size, PetscBool **__pyx_v_data) {
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("iarray_b", 0);

  /* "include/arraynpy.pxi":149
 * 
 * cdef inline ndarray iarray_b(object ob, PetscInt* size, PetscBool** data):
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_BOOL)             # <<<<<<<<<<<<<<
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscBool*> PyArray_DATA(ary)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_iarray(__pyx_v_ob, NPY_PETSC_BOOL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 149, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":150
 * cdef inline ndarray iarray_b(object ob, PetscInt* size, PetscBool** data):
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_BOOL)
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)             # <<<<<<<<<<<<<<
 *     if data != NULL: data[0] = <PetscBool*> PyArray_DATA(ary)
 *     return ary
 */
  __pyx_t_2 = ((__pyx_v_size != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_size[0]) = ((PetscInt)PyArray_SIZE(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":151
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_BOOL)
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscBool*> PyArray_DATA(ary)             # <<<<<<<<<<<<<<
 *     return ary
 * 
 */
  __pyx_t_2 = ((__pyx_v_data != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_data[0]) = ((PetscBool *)PyArray_DATA(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":152
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscBool*> PyArray_DATA(ary)
 *     return ary             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray iarray_s(object ob, PetscInt* size, PetscScalar** data):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ary));
  __pyx_r = __pyx_v_ary;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":148
 *     return ary
 * 
 * cdef inline ndarray iarray_b(object ob, PetscInt* size, PetscBool** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_BOOL)
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.iarray_b", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":154
 *     return ary
 * 
 * cdef inline ndarray iarray_s(object ob, PetscInt* size, PetscScalar** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_SCALAR)
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_iarray_s(PyObject *__pyx_v_ob, PetscInt *__pyx_v_size, PetscScalar **__pyx_v_data) {
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("iarray_s", 0);

  /* "include/arraynpy.pxi":155
 * 
 * cdef inline ndarray iarray_s(object ob, PetscInt* size, PetscScalar** data):
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_SCALAR)             # <<<<<<<<<<<<<<
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscScalar*> PyArray_DATA(ary)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_iarray(__pyx_v_ob, NPY_PETSC_SCALAR)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 155, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":156
 * cdef inline ndarray iarray_s(object ob, PetscInt* size, PetscScalar** data):
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_SCALAR)
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)             # <<<<<<<<<<<<<<
 *     if data != NULL: data[0] = <PetscScalar*> PyArray_DATA(ary)
 *     return ary
 */
  __pyx_t_2 = ((__pyx_v_size != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_size[0]) = ((PetscInt)PyArray_SIZE(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":157
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_SCALAR)
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscScalar*> PyArray_DATA(ary)             # <<<<<<<<<<<<<<
 *     return ary
 * 
 */
  __pyx_t_2 = ((__pyx_v_data != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_data[0]) = ((PetscScalar *)PyArray_DATA(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":158
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscScalar*> PyArray_DATA(ary)
 *     return ary             # <<<<<<<<<<<<<<
 * 
 * # --------------------------------------------------------------------
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ary));
  __pyx_r = __pyx_v_ary;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":154
 *     return ary
 * 
 * cdef inline ndarray iarray_s(object ob, PetscInt* size, PetscScalar** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = iarray(ob, NPY_PETSC_SCALAR)
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.iarray_s", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":162
 * # --------------------------------------------------------------------
 * 
 * cdef inline ndarray oarray(object ob, int typenum):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = PyArray_FROM_OTF(
 *         ob, typenum, NPY_ARRAY_ALIGNED|NPY_ARRAY_WRITEABLE|NPY_ARRAY_NOTSWAPPED)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_oarray(PyObject *__pyx_v_ob, int __pyx_v_typenum) {
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("oarray", 0);

  /* "include/arraynpy.pxi":163
 * 
 * cdef inline ndarray oarray(object ob, int typenum):
 *     cdef ndarray ary = PyArray_FROM_OTF(             # <<<<<<<<<<<<<<
 *         ob, typenum, NPY_ARRAY_ALIGNED|NPY_ARRAY_WRITEABLE|NPY_ARRAY_NOTSWAPPED)
 *     if PyArray_ISCONTIGUOUS(ary): return ary
 */
  __pyx_t_1 = ((PyObject *)PyArray_FROM_OTF(__pyx_v_ob, __pyx_v_typenum, ((NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE) | NPY_ARRAY_NOTSWAPPED))); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 163, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":165
 *     cdef ndarray ary = PyArray_FROM_OTF(
 *         ob, typenum, NPY_ARRAY_ALIGNED|NPY_ARRAY_WRITEABLE|NPY_ARRAY_NOTSWAPPED)
 *     if PyArray_ISCONTIGUOUS(ary): return ary             # <<<<<<<<<<<<<<
 *     if PyArray_ISFORTRAN(ary):    return ary
 *     return PyArray_Copy(ary)
 */
  __pyx_t_2 = (PyArray_ISCONTIGUOUS(__pyx_v_ary) != 0);
  if (__pyx_t_2) {
    __Pyx_XDECREF(((PyObject *)__pyx_r));
    __Pyx_INCREF(((PyObject *)__pyx_v_ary));
    __pyx_r = __pyx_v_ary;
    goto __pyx_L0;
  }

  /* "include/arraynpy.pxi":166
 *         ob, typenum, NPY_ARRAY_ALIGNED|NPY_ARRAY_WRITEABLE|NPY_ARRAY_NOTSWAPPED)
 *     if PyArray_ISCONTIGUOUS(ary): return ary
 *     if PyArray_ISFORTRAN(ary):    return ary             # <<<<<<<<<<<<<<
 *     return PyArray_Copy(ary)
 * 
 */
  __pyx_t_2 = (PyArray_ISFORTRAN(__pyx_v_ary) != 0);
  if (__pyx_t_2) {
    __Pyx_XDECREF(((PyObject *)__pyx_r));
    __Pyx_INCREF(((PyObject *)__pyx_v_ary));
    __pyx_r = __pyx_v_ary;
    goto __pyx_L0;
  }

  /* "include/arraynpy.pxi":167
 *     if PyArray_ISCONTIGUOUS(ary): return ary
 *     if PyArray_ISFORTRAN(ary):    return ary
 *     return PyArray_Copy(ary)             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray oarray_i(object ob, PetscInt* size, PetscInt** data):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __pyx_t_1 = ((PyObject *)PyArray_Copy(__pyx_v_ary)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 167, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":162
 * # --------------------------------------------------------------------
 * 
 * cdef inline ndarray oarray(object ob, int typenum):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = PyArray_FROM_OTF(
 *         ob, typenum, NPY_ARRAY_ALIGNED|NPY_ARRAY_WRITEABLE|NPY_ARRAY_NOTSWAPPED)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.oarray", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":169
 *     return PyArray_Copy(ary)
 * 
 * cdef inline ndarray oarray_i(object ob, PetscInt* size, PetscInt** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_INT)
 *     if size != NULL: size[0] = <PetscInt>  PyArray_SIZE(ary)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_oarray_i(PyObject *__pyx_v_ob, PetscInt *__pyx_v_size, PetscInt **__pyx_v_data) {
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("oarray_i", 0);

  /* "include/arraynpy.pxi":170
 * 
 * cdef inline ndarray oarray_i(object ob, PetscInt* size, PetscInt** data):
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_INT)             # <<<<<<<<<<<<<<
 *     if size != NULL: size[0] = <PetscInt>  PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscInt*> PyArray_DATA(ary)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_oarray(__pyx_v_ob, NPY_PETSC_INT)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 170, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":171
 * cdef inline ndarray oarray_i(object ob, PetscInt* size, PetscInt** data):
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_INT)
 *     if size != NULL: size[0] = <PetscInt>  PyArray_SIZE(ary)             # <<<<<<<<<<<<<<
 *     if data != NULL: data[0] = <PetscInt*> PyArray_DATA(ary)
 *     return ary
 */
  __pyx_t_2 = ((__pyx_v_size != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_size[0]) = ((PetscInt)PyArray_SIZE(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":172
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_INT)
 *     if size != NULL: size[0] = <PetscInt>  PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscInt*> PyArray_DATA(ary)             # <<<<<<<<<<<<<<
 *     return ary
 * 
 */
  __pyx_t_2 = ((__pyx_v_data != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_data[0]) = ((PetscInt *)PyArray_DATA(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":173
 *     if size != NULL: size[0] = <PetscInt>  PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscInt*> PyArray_DATA(ary)
 *     return ary             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray oarray_r(object ob, PetscInt* size, PetscReal** data):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ary));
  __pyx_r = __pyx_v_ary;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":169
 *     return PyArray_Copy(ary)
 * 
 * cdef inline ndarray oarray_i(object ob, PetscInt* size, PetscInt** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_INT)
 *     if size != NULL: size[0] = <PetscInt>  PyArray_SIZE(ary)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.oarray_i", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":175
 *     return ary
 * 
 * cdef inline ndarray oarray_r(object ob, PetscInt* size, PetscReal** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_REAL)
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_oarray_r(PyObject *__pyx_v_ob, PetscInt *__pyx_v_size, PetscReal **__pyx_v_data) {
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("oarray_r", 0);

  /* "include/arraynpy.pxi":176
 * 
 * cdef inline ndarray oarray_r(object ob, PetscInt* size, PetscReal** data):
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_REAL)             # <<<<<<<<<<<<<<
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscReal*> PyArray_DATA(ary)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_oarray(__pyx_v_ob, NPY_PETSC_REAL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 176, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":177
 * cdef inline ndarray oarray_r(object ob, PetscInt* size, PetscReal** data):
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_REAL)
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)             # <<<<<<<<<<<<<<
 *     if data != NULL: data[0] = <PetscReal*> PyArray_DATA(ary)
 *     return ary
 */
  __pyx_t_2 = ((__pyx_v_size != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_size[0]) = ((PetscInt)PyArray_SIZE(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":178
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_REAL)
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscReal*> PyArray_DATA(ary)             # <<<<<<<<<<<<<<
 *     return ary
 * 
 */
  __pyx_t_2 = ((__pyx_v_data != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_data[0]) = ((PetscReal *)PyArray_DATA(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":179
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscReal*> PyArray_DATA(ary)
 *     return ary             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray oarray_s(object ob, PetscInt* size, PetscScalar** data):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ary));
  __pyx_r = __pyx_v_ary;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":175
 *     return ary
 * 
 * cdef inline ndarray oarray_r(object ob, PetscInt* size, PetscReal** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_REAL)
 *     if size != NULL: size[0] = <PetscInt>   PyArray_SIZE(ary)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.oarray_r", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":181
 *     return ary
 * 
 * cdef inline ndarray oarray_s(object ob, PetscInt* size, PetscScalar** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_SCALAR)
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_oarray_s(PyObject *__pyx_v_ob, PetscInt *__pyx_v_size, PetscScalar **__pyx_v_data) {
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("oarray_s", 0);

  /* "include/arraynpy.pxi":182
 * 
 * cdef inline ndarray oarray_s(object ob, PetscInt* size, PetscScalar** data):
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_SCALAR)             # <<<<<<<<<<<<<<
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscScalar*> PyArray_DATA(ary)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_oarray(__pyx_v_ob, NPY_PETSC_SCALAR)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 182, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":183
 * cdef inline ndarray oarray_s(object ob, PetscInt* size, PetscScalar** data):
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_SCALAR)
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)             # <<<<<<<<<<<<<<
 *     if data != NULL: data[0] = <PetscScalar*> PyArray_DATA(ary)
 *     return ary
 */
  __pyx_t_2 = ((__pyx_v_size != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_size[0]) = ((PetscInt)PyArray_SIZE(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":184
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_SCALAR)
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscScalar*> PyArray_DATA(ary)             # <<<<<<<<<<<<<<
 *     return ary
 * 
 */
  __pyx_t_2 = ((__pyx_v_data != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_data[0]) = ((PetscScalar *)PyArray_DATA(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":185
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscScalar*> PyArray_DATA(ary)
 *     return ary             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray oarray_p(object ob, PetscInt* size, void** data):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ary));
  __pyx_r = __pyx_v_ary;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":181
 *     return ary
 * 
 * cdef inline ndarray oarray_s(object ob, PetscInt* size, PetscScalar** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = oarray(ob, NPY_PETSC_SCALAR)
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.oarray_s", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":187
 *     return ary
 * 
 * cdef inline ndarray oarray_p(object ob, PetscInt* size, void** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = oarray(ob, NPY_INTP)
 *     if size != NULL: size[0] = <PetscInt> PyArray_SIZE(ary)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_oarray_p(PyObject *__pyx_v_ob, PetscInt *__pyx_v_size, void **__pyx_v_data) {
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("oarray_p", 0);

  /* "include/arraynpy.pxi":188
 * 
 * cdef inline ndarray oarray_p(object ob, PetscInt* size, void** data):
 *     cdef ndarray ary = oarray(ob, NPY_INTP)             # <<<<<<<<<<<<<<
 *     if size != NULL: size[0] = <PetscInt> PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <void*>    PyArray_DATA(ary)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_oarray(__pyx_v_ob, NPY_INTP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 188, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":189
 * cdef inline ndarray oarray_p(object ob, PetscInt* size, void** data):
 *     cdef ndarray ary = oarray(ob, NPY_INTP)
 *     if size != NULL: size[0] = <PetscInt> PyArray_SIZE(ary)             # <<<<<<<<<<<<<<
 *     if data != NULL: data[0] = <void*>    PyArray_DATA(ary)
 *     return ary
 */
  __pyx_t_2 = ((__pyx_v_size != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_size[0]) = ((PetscInt)PyArray_SIZE(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":190
 *     cdef ndarray ary = oarray(ob, NPY_INTP)
 *     if size != NULL: size[0] = <PetscInt> PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <void*>    PyArray_DATA(ary)             # <<<<<<<<<<<<<<
 *     return ary
 * 
 */
  __pyx_t_2 = ((__pyx_v_data != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_data[0]) = ((void *)PyArray_DATA(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":191
 *     if size != NULL: size[0] = <PetscInt> PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <void*>    PyArray_DATA(ary)
 *     return ary             # <<<<<<<<<<<<<<
 * 
 * # --------------------------------------------------------------------
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ary));
  __pyx_r = __pyx_v_ary;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":187
 *     return ary
 * 
 * cdef inline ndarray oarray_p(object ob, PetscInt* size, void** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = oarray(ob, NPY_INTP)
 *     if size != NULL: size[0] = <PetscInt> PyArray_SIZE(ary)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.oarray_p", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":195
 * # --------------------------------------------------------------------
 * 
 * cdef inline ndarray ocarray_s(object ob, PetscInt* size, PetscScalar** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = PyArray_FROM_OTF(
 *         ob, NPY_PETSC_SCALAR, NPY_ARRAY_CARRAY|NPY_ARRAY_NOTSWAPPED)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_ocarray_s(PyObject *__pyx_v_ob, PetscInt *__pyx_v_size, PetscScalar **__pyx_v_data) {
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ocarray_s", 0);

  /* "include/arraynpy.pxi":196
 * 
 * cdef inline ndarray ocarray_s(object ob, PetscInt* size, PetscScalar** data):
 *     cdef ndarray ary = PyArray_FROM_OTF(             # <<<<<<<<<<<<<<
 *         ob, NPY_PETSC_SCALAR, NPY_ARRAY_CARRAY|NPY_ARRAY_NOTSWAPPED)
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 */
  __pyx_t_1 = ((PyObject *)PyArray_FROM_OTF(__pyx_v_ob, NPY_PETSC_SCALAR, (NPY_ARRAY_CARRAY | NPY_ARRAY_NOTSWAPPED))); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 196, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":198
 *     cdef ndarray ary = PyArray_FROM_OTF(
 *         ob, NPY_PETSC_SCALAR, NPY_ARRAY_CARRAY|NPY_ARRAY_NOTSWAPPED)
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)             # <<<<<<<<<<<<<<
 *     if data != NULL: data[0] = <PetscScalar*> PyArray_DATA(ary)
 *     return ary
 */
  __pyx_t_2 = ((__pyx_v_size != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_size[0]) = ((PetscInt)PyArray_SIZE(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":199
 *         ob, NPY_PETSC_SCALAR, NPY_ARRAY_CARRAY|NPY_ARRAY_NOTSWAPPED)
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscScalar*> PyArray_DATA(ary)             # <<<<<<<<<<<<<<
 *     return ary
 * 
 */
  __pyx_t_2 = ((__pyx_v_data != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_data[0]) = ((PetscScalar *)PyArray_DATA(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":200
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscScalar*> PyArray_DATA(ary)
 *     return ary             # <<<<<<<<<<<<<<
 * 
 * cdef inline ndarray ofarray_s(object ob, PetscInt* size, PetscScalar** data):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ary));
  __pyx_r = __pyx_v_ary;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":195
 * # --------------------------------------------------------------------
 * 
 * cdef inline ndarray ocarray_s(object ob, PetscInt* size, PetscScalar** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = PyArray_FROM_OTF(
 *         ob, NPY_PETSC_SCALAR, NPY_ARRAY_CARRAY|NPY_ARRAY_NOTSWAPPED)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.ocarray_s", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "include/arraynpy.pxi":202
 *     return ary
 * 
 * cdef inline ndarray ofarray_s(object ob, PetscInt* size, PetscScalar** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = PyArray_FROM_OTF(
 *         ob, NPY_PETSC_SCALAR, NPY_ARRAY_FARRAY|NPY_ARRAY_NOTSWAPPED)
 */

static CYTHON_INLINE PyArrayObject *__pyx_f_8slepc4py_5SLEPc_ofarray_s(PyObject *__pyx_v_ob, PetscInt *__pyx_v_size, PetscScalar **__pyx_v_data) {
  PyArrayObject *__pyx_v_ary = 0;
  PyArrayObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ofarray_s", 0);

  /* "include/arraynpy.pxi":203
 * 
 * cdef inline ndarray ofarray_s(object ob, PetscInt* size, PetscScalar** data):
 *     cdef ndarray ary = PyArray_FROM_OTF(             # <<<<<<<<<<<<<<
 *         ob, NPY_PETSC_SCALAR, NPY_ARRAY_FARRAY|NPY_ARRAY_NOTSWAPPED)
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 */
  __pyx_t_1 = ((PyObject *)PyArray_FROM_OTF(__pyx_v_ob, NPY_PETSC_SCALAR, (NPY_ARRAY_FARRAY | NPY_ARRAY_NOTSWAPPED))); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 203, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ary = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "include/arraynpy.pxi":205
 *     cdef ndarray ary = PyArray_FROM_OTF(
 *         ob, NPY_PETSC_SCALAR, NPY_ARRAY_FARRAY|NPY_ARRAY_NOTSWAPPED)
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)             # <<<<<<<<<<<<<<
 *     if data != NULL: data[0] = <PetscScalar*> PyArray_DATA(ary)
 *     return ary
 */
  __pyx_t_2 = ((__pyx_v_size != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_size[0]) = ((PetscInt)PyArray_SIZE(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":206
 *         ob, NPY_PETSC_SCALAR, NPY_ARRAY_FARRAY|NPY_ARRAY_NOTSWAPPED)
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscScalar*> PyArray_DATA(ary)             # <<<<<<<<<<<<<<
 *     return ary
 * 
 */
  __pyx_t_2 = ((__pyx_v_data != NULL) != 0);
  if (__pyx_t_2) {
    (__pyx_v_data[0]) = ((PetscScalar *)PyArray_DATA(__pyx_v_ary));
  }

  /* "include/arraynpy.pxi":207
 *     if size != NULL: size[0] = <PetscInt>     PyArray_SIZE(ary)
 *     if data != NULL: data[0] = <PetscScalar*> PyArray_DATA(ary)
 *     return ary             # <<<<<<<<<<<<<<
 * 
 * # --------------------------------------------------------------------
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ary));
  __pyx_r = __pyx_v_ary;
  goto __pyx_L0;

  /* "include/arraynpy.pxi":202
 *     return ary
 * 
 * cdef inline ndarray ofarray_s(object ob, PetscInt* size, PetscScalar** data):             # <<<<<<<<<<<<<<
 *     cdef ndarray ary = PyArray_FROM_OTF(
 *         ob, NPY_PETSC_SCALAR, NPY_ARRAY_FARRAY|NPY_ARRAY_NOTSWAPPED)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.ofarray_s", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ary);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepcmpi.pxi":15
 * 
 * from petsc4py.PETSc cimport GetComm
 * cdef inline MPI_Comm def_Comm(object comm, MPI_Comm defv) except *:             # <<<<<<<<<<<<<<
 *      return GetComm(comm, defv)
 * 
 */

static CYTHON_INLINE MPI_Comm __pyx_f_8slepc4py_5SLEPc_def_Comm(PyObject *__pyx_v_comm, MPI_Comm __pyx_v_defv) {
  MPI_Comm __pyx_r;
  __Pyx_RefNannyDeclarations
  MPI_Comm __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("def_Comm", 0);

  /* "SLEPc/slepcmpi.pxi":16
 * from petsc4py.PETSc cimport GetComm
 * cdef inline MPI_Comm def_Comm(object comm, MPI_Comm defv) except *:
 *      return GetComm(comm, defv)             # <<<<<<<<<<<<<<
 * 
 * from petsc4py.PETSc cimport GetCommDefault
 */
  __pyx_t_1 = __pyx_f_8petsc4py_5PETSc_GetComm(__pyx_v_comm, __pyx_v_defv); if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L1_error)
  __pyx_r = __pyx_t_1;
  goto __pyx_L0;

  /* "SLEPc/slepcmpi.pxi":15
 * 
 * from petsc4py.PETSc cimport GetComm
 * cdef inline MPI_Comm def_Comm(object comm, MPI_Comm defv) except *:             # <<<<<<<<<<<<<<
 *      return GetComm(comm, defv)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.def_Comm", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepcmpi.pxi":19
 * 
 * from petsc4py.PETSc cimport GetCommDefault
 * cdef inline MPI_Comm SLEPC_COMM_DEFAULT():             # <<<<<<<<<<<<<<
 *      return GetCommDefault()
 * 
 */

static CYTHON_INLINE MPI_Comm __pyx_f_8slepc4py_5SLEPc_SLEPC_COMM_DEFAULT(void) {
  MPI_Comm __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("SLEPC_COMM_DEFAULT", 0);

  /* "SLEPc/slepcmpi.pxi":20
 * from petsc4py.PETSc cimport GetCommDefault
 * cdef inline MPI_Comm SLEPC_COMM_DEFAULT():
 *      return GetCommDefault()             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = __pyx_f_8petsc4py_5PETSc_GetCommDefault();
  goto __pyx_L0;

  /* "SLEPc/slepcmpi.pxi":19
 * 
 * from petsc4py.PETSc cimport GetCommDefault
 * cdef inline MPI_Comm SLEPC_COMM_DEFAULT():             # <<<<<<<<<<<<<<
 *      return GetCommDefault()
 * 
 */

  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepcsys.pxi":57
 *     int SlepcHasExternalPackage(const char[],PetscBool*)
 * 
 * cdef inline PetscMatStructure matstructure(object structure) \             # <<<<<<<<<<<<<<
 *     except <PetscMatStructure>(-1):
 *     if   structure is None:  return MAT_DIFFERENT_NONZERO_PATTERN
 */

static CYTHON_INLINE MatStructure __pyx_f_8slepc4py_5SLEPc_matstructure(PyObject *__pyx_v_structure) {
  MatStructure __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  MatStructure __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("matstructure", 0);

  /* "SLEPc/slepcsys.pxi":59
 * cdef inline PetscMatStructure matstructure(object structure) \
 *     except <PetscMatStructure>(-1):
 *     if   structure is None:  return MAT_DIFFERENT_NONZERO_PATTERN             # <<<<<<<<<<<<<<
 *     elif structure is False: return MAT_DIFFERENT_NONZERO_PATTERN
 *     elif structure is True:  return MAT_SAME_NONZERO_PATTERN
 */
  __pyx_t_1 = (__pyx_v_structure == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_r = DIFFERENT_NONZERO_PATTERN;
    goto __pyx_L0;
  }

  /* "SLEPc/slepcsys.pxi":60
 *     except <PetscMatStructure>(-1):
 *     if   structure is None:  return MAT_DIFFERENT_NONZERO_PATTERN
 *     elif structure is False: return MAT_DIFFERENT_NONZERO_PATTERN             # <<<<<<<<<<<<<<
 *     elif structure is True:  return MAT_SAME_NONZERO_PATTERN
 *     else:                    return structure
 */
  __pyx_t_2 = (__pyx_v_structure == Py_False);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_r = DIFFERENT_NONZERO_PATTERN;
    goto __pyx_L0;
  }

  /* "SLEPc/slepcsys.pxi":61
 *     if   structure is None:  return MAT_DIFFERENT_NONZERO_PATTERN
 *     elif structure is False: return MAT_DIFFERENT_NONZERO_PATTERN
 *     elif structure is True:  return MAT_SAME_NONZERO_PATTERN             # <<<<<<<<<<<<<<
 *     else:                    return structure
 * 
 */
  __pyx_t_1 = (__pyx_v_structure == Py_True);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_r = SAME_NONZERO_PATTERN;
    goto __pyx_L0;
  }

  /* "SLEPc/slepcsys.pxi":62
 *     elif structure is False: return MAT_DIFFERENT_NONZERO_PATTERN
 *     elif structure is True:  return MAT_SAME_NONZERO_PATTERN
 *     else:                    return structure             # <<<<<<<<<<<<<<
 * 
 * cdef inline int PetscINCREF(PetscObject *obj):
 */
  /*else*/ {
    __pyx_t_3 = ((MatStructure)__Pyx_PyInt_As_MatStructure(__pyx_v_structure)); if (unlikely(PyErr_Occurred())) __PYX_ERR(7, 62, __pyx_L1_error)
    __pyx_r = __pyx_t_3;
    goto __pyx_L0;
  }

  /* "SLEPc/slepcsys.pxi":57
 *     int SlepcHasExternalPackage(const char[],PetscBool*)
 * 
 * cdef inline PetscMatStructure matstructure(object structure) \             # <<<<<<<<<<<<<<
 *     except <PetscMatStructure>(-1):
 *     if   structure is None:  return MAT_DIFFERENT_NONZERO_PATTERN
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.matstructure", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = ((MatStructure)-1L);
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepcsys.pxi":64
 *     else:                    return structure
 * 
 * cdef inline int PetscINCREF(PetscObject *obj):             # <<<<<<<<<<<<<<
 *     if obj    == NULL: return 0
 *     if obj[0] == NULL: return 0
 */

static CYTHON_INLINE int __pyx_f_8slepc4py_5SLEPc_PetscINCREF(PetscObject *__pyx_v_obj) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  __Pyx_RefNannySetupContext("PetscINCREF", 0);

  /* "SLEPc/slepcsys.pxi":65
 * 
 * cdef inline int PetscINCREF(PetscObject *obj):
 *     if obj    == NULL: return 0             # <<<<<<<<<<<<<<
 *     if obj[0] == NULL: return 0
 *     return PetscObjectReference(obj[0])
 */
  __pyx_t_1 = ((__pyx_v_obj == NULL) != 0);
  if (__pyx_t_1) {
    __pyx_r = 0;
    goto __pyx_L0;
  }

  /* "SLEPc/slepcsys.pxi":66
 * cdef inline int PetscINCREF(PetscObject *obj):
 *     if obj    == NULL: return 0
 *     if obj[0] == NULL: return 0             # <<<<<<<<<<<<<<
 *     return PetscObjectReference(obj[0])
 * 
 */
  __pyx_t_1 = (((__pyx_v_obj[0]) == NULL) != 0);
  if (__pyx_t_1) {
    __pyx_r = 0;
    goto __pyx_L0;
  }

  /* "SLEPc/slepcsys.pxi":67
 *     if obj    == NULL: return 0
 *     if obj[0] == NULL: return 0
 *     return PetscObjectReference(obj[0])             # <<<<<<<<<<<<<<
 * 
 * cdef inline int SlepcCLEAR(PetscObject* obj):
 */
  __pyx_r = PetscObjectReference((__pyx_v_obj[0]));
  goto __pyx_L0;

  /* "SLEPc/slepcsys.pxi":64
 *     else:                    return structure
 * 
 * cdef inline int PetscINCREF(PetscObject *obj):             # <<<<<<<<<<<<<<
 *     if obj    == NULL: return 0
 *     if obj[0] == NULL: return 0
 */

  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepcsys.pxi":69
 *     return PetscObjectReference(obj[0])
 * 
 * cdef inline int SlepcCLEAR(PetscObject* obj):             # <<<<<<<<<<<<<<
 *     if obj    == NULL: return 0
 *     if obj[0] == NULL: return 0
 */

static CYTHON_INLINE int __pyx_f_8slepc4py_5SLEPc_SlepcCLEAR(PetscObject *__pyx_v_obj) {
  PetscObject __pyx_v_tmp;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  __Pyx_RefNannySetupContext("SlepcCLEAR", 0);

  /* "SLEPc/slepcsys.pxi":70
 * 
 * cdef inline int SlepcCLEAR(PetscObject* obj):
 *     if obj    == NULL: return 0             # <<<<<<<<<<<<<<
 *     if obj[0] == NULL: return 0
 *     cdef PetscObject tmp
 */
  __pyx_t_1 = ((__pyx_v_obj == NULL) != 0);
  if (__pyx_t_1) {
    __pyx_r = 0;
    goto __pyx_L0;
  }

  /* "SLEPc/slepcsys.pxi":71
 * cdef inline int SlepcCLEAR(PetscObject* obj):
 *     if obj    == NULL: return 0
 *     if obj[0] == NULL: return 0             # <<<<<<<<<<<<<<
 *     cdef PetscObject tmp
 *     tmp = obj[0]; obj[0] = NULL
 */
  __pyx_t_1 = (((__pyx_v_obj[0]) == NULL) != 0);
  if (__pyx_t_1) {
    __pyx_r = 0;
    goto __pyx_L0;
  }

  /* "SLEPc/slepcsys.pxi":73
 *     if obj[0] == NULL: return 0
 *     cdef PetscObject tmp
 *     tmp = obj[0]; obj[0] = NULL             # <<<<<<<<<<<<<<
 *     return PetscObjectDestroy(&tmp)
 * 
 */
  __pyx_v_tmp = (__pyx_v_obj[0]);
  (__pyx_v_obj[0]) = NULL;

  /* "SLEPc/slepcsys.pxi":74
 *     cdef PetscObject tmp
 *     tmp = obj[0]; obj[0] = NULL
 *     return PetscObjectDestroy(&tmp)             # <<<<<<<<<<<<<<
 * 
 * cdef inline PetscViewer def_Viewer(Viewer viewer):
 */
  __pyx_r = PetscObjectDestroy((&__pyx_v_tmp));
  goto __pyx_L0;

  /* "SLEPc/slepcsys.pxi":69
 *     return PetscObjectReference(obj[0])
 * 
 * cdef inline int SlepcCLEAR(PetscObject* obj):             # <<<<<<<<<<<<<<
 *     if obj    == NULL: return 0
 *     if obj[0] == NULL: return 0
 */

  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepcsys.pxi":76
 *     return PetscObjectDestroy(&tmp)
 * 
 * cdef inline PetscViewer def_Viewer(Viewer viewer):             # <<<<<<<<<<<<<<
 *    return viewer.vwr if viewer is not None else <PetscViewer>NULL
 * 
 */

static CYTHON_INLINE PetscViewer __pyx_f_8slepc4py_5SLEPc_def_Viewer(struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_r;
  __Pyx_RefNannyDeclarations
  PetscViewer __pyx_t_1;
  int __pyx_t_2;
  __Pyx_RefNannySetupContext("def_Viewer", 0);

  /* "SLEPc/slepcsys.pxi":77
 * 
 * cdef inline PetscViewer def_Viewer(Viewer viewer):
 *    return viewer.vwr if viewer is not None else <PetscViewer>NULL             # <<<<<<<<<<<<<<
 * 
 * cdef inline KSP ref_KSP(PetscKSP ksp):
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_viewer) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_viewer->vwr;
  } else {
    __pyx_t_1 = ((PetscViewer)NULL);
  }
  __pyx_r = __pyx_t_1;
  goto __pyx_L0;

  /* "SLEPc/slepcsys.pxi":76
 *     return PetscObjectDestroy(&tmp)
 * 
 * cdef inline PetscViewer def_Viewer(Viewer viewer):             # <<<<<<<<<<<<<<
 *    return viewer.vwr if viewer is not None else <PetscViewer>NULL
 * 
 */

  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepcsys.pxi":79
 *    return viewer.vwr if viewer is not None else <PetscViewer>NULL
 * 
 * cdef inline KSP ref_KSP(PetscKSP ksp):             # <<<<<<<<<<<<<<
 *     cdef KSP ob = <KSP> KSP()
 *     ob.ksp = ksp
 */

static CYTHON_INLINE struct PyPetscKSPObject *__pyx_f_8slepc4py_5SLEPc_ref_KSP(KSP __pyx_v_ksp) {
  struct PyPetscKSPObject *__pyx_v_ob = 0;
  struct PyPetscKSPObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ref_KSP", 0);

  /* "SLEPc/slepcsys.pxi":80
 * 
 * cdef inline KSP ref_KSP(PetscKSP ksp):
 *     cdef KSP ob = <KSP> KSP()             # <<<<<<<<<<<<<<
 *     ob.ksp = ksp
 *     PetscINCREF(ob.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_KSP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 80, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_t_1;
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_ob = ((struct PyPetscKSPObject *)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/slepcsys.pxi":81
 * cdef inline KSP ref_KSP(PetscKSP ksp):
 *     cdef KSP ob = <KSP> KSP()
 *     ob.ksp = ksp             # <<<<<<<<<<<<<<
 *     PetscINCREF(ob.obj)
 *     return ob
 */
  __pyx_v_ob->ksp = __pyx_v_ksp;

  /* "SLEPc/slepcsys.pxi":82
 *     cdef KSP ob = <KSP> KSP()
 *     ob.ksp = ksp
 *     PetscINCREF(ob.obj)             # <<<<<<<<<<<<<<
 *     return ob
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ob->__pyx_base.obj));

  /* "SLEPc/slepcsys.pxi":83
 *     ob.ksp = ksp
 *     PetscINCREF(ob.obj)
 *     return ob             # <<<<<<<<<<<<<<
 * 
 * cdef inline Mat ref_Mat(PetscMat mat):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ob));
  __pyx_r = __pyx_v_ob;
  goto __pyx_L0;

  /* "SLEPc/slepcsys.pxi":79
 *    return viewer.vwr if viewer is not None else <PetscViewer>NULL
 * 
 * cdef inline KSP ref_KSP(PetscKSP ksp):             # <<<<<<<<<<<<<<
 *     cdef KSP ob = <KSP> KSP()
 *     ob.ksp = ksp
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ref_KSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepcsys.pxi":85
 *     return ob
 * 
 * cdef inline Mat ref_Mat(PetscMat mat):             # <<<<<<<<<<<<<<
 *     cdef Mat ob = <Mat> Mat()
 *     ob.mat = mat
 */

static CYTHON_INLINE struct PyPetscMatObject *__pyx_f_8slepc4py_5SLEPc_ref_Mat(Mat __pyx_v_mat) {
  struct PyPetscMatObject *__pyx_v_ob = 0;
  struct PyPetscMatObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ref_Mat", 0);

  /* "SLEPc/slepcsys.pxi":86
 * 
 * cdef inline Mat ref_Mat(PetscMat mat):
 *     cdef Mat ob = <Mat> Mat()             # <<<<<<<<<<<<<<
 *     ob.mat = mat
 *     PetscINCREF(ob.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 86, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_t_1;
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_ob = ((struct PyPetscMatObject *)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/slepcsys.pxi":87
 * cdef inline Mat ref_Mat(PetscMat mat):
 *     cdef Mat ob = <Mat> Mat()
 *     ob.mat = mat             # <<<<<<<<<<<<<<
 *     PetscINCREF(ob.obj)
 *     return ob
 */
  __pyx_v_ob->mat = __pyx_v_mat;

  /* "SLEPc/slepcsys.pxi":88
 *     cdef Mat ob = <Mat> Mat()
 *     ob.mat = mat
 *     PetscINCREF(ob.obj)             # <<<<<<<<<<<<<<
 *     return ob
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ob->__pyx_base.obj));

  /* "SLEPc/slepcsys.pxi":89
 *     ob.mat = mat
 *     PetscINCREF(ob.obj)
 *     return ob             # <<<<<<<<<<<<<<
 * 
 * cdef inline Vec ref_Vec(PetscVec vec):
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ob));
  __pyx_r = __pyx_v_ob;
  goto __pyx_L0;

  /* "SLEPc/slepcsys.pxi":85
 *     return ob
 * 
 * cdef inline Mat ref_Mat(PetscMat mat):             # <<<<<<<<<<<<<<
 *     cdef Mat ob = <Mat> Mat()
 *     ob.mat = mat
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ref_Mat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepcsys.pxi":91
 *     return ob
 * 
 * cdef inline Vec ref_Vec(PetscVec vec):             # <<<<<<<<<<<<<<
 *     cdef Vec ob = <Vec> Vec()
 *     ob.vec = vec
 */

static CYTHON_INLINE struct PyPetscVecObject *__pyx_f_8slepc4py_5SLEPc_ref_Vec(Vec __pyx_v_vec) {
  struct PyPetscVecObject *__pyx_v_ob = 0;
  struct PyPetscVecObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ref_Vec", 0);

  /* "SLEPc/slepcsys.pxi":92
 * 
 * cdef inline Vec ref_Vec(PetscVec vec):
 *     cdef Vec ob = <Vec> Vec()             # <<<<<<<<<<<<<<
 *     ob.vec = vec
 *     PetscINCREF(ob.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Vec)); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 92, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_t_1;
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_ob = ((struct PyPetscVecObject *)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/slepcsys.pxi":93
 * cdef inline Vec ref_Vec(PetscVec vec):
 *     cdef Vec ob = <Vec> Vec()
 *     ob.vec = vec             # <<<<<<<<<<<<<<
 *     PetscINCREF(ob.obj)
 *     return ob
 */
  __pyx_v_ob->vec = __pyx_v_vec;

  /* "SLEPc/slepcsys.pxi":94
 *     cdef Vec ob = <Vec> Vec()
 *     ob.vec = vec
 *     PetscINCREF(ob.obj)             # <<<<<<<<<<<<<<
 *     return ob
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ob->__pyx_base.obj));

  /* "SLEPc/slepcsys.pxi":95
 *     ob.vec = vec
 *     PetscINCREF(ob.obj)
 *     return ob             # <<<<<<<<<<<<<<
 * 
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ob));
  __pyx_r = __pyx_v_ob;
  goto __pyx_L0;

  /* "SLEPc/slepcsys.pxi":91
 *     return ob
 * 
 * cdef inline Vec ref_Vec(PetscVec vec):             # <<<<<<<<<<<<<<
 *     cdef Vec ob = <Vec> Vec()
 *     ob.vec = vec
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ref_Vec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepcbv.pxi":118
 *     int BVRestoreMat(SlepcBV,PetscMat*)
 * 
 * cdef inline int BV_Sizes(             # <<<<<<<<<<<<<<
 *     object size,
 *     PetscInt *_n,
 */

static CYTHON_INLINE int __pyx_f_8slepc4py_5SLEPc_BV_Sizes(PyObject *__pyx_v_size, PetscInt *__pyx_v__n, PetscInt *__pyx_v__N) {
  PetscInt __pyx_v_n;
  PetscInt __pyx_v_N;
  PyObject *__pyx_v_on = 0;
  PyObject *__pyx_v_oN = 0;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *(*__pyx_t_7)(PyObject *);
  int __pyx_t_8;
  int __pyx_t_9;
  int __pyx_t_10;
  PetscInt __pyx_t_11;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("BV_Sizes", 0);

  /* "SLEPc/slepcbv.pxi":124
 *     ) except -1:
 *     # unpack and get local and global sizes
 *     cdef PetscInt n=PETSC_DECIDE, N=PETSC_DECIDE             # <<<<<<<<<<<<<<
 *     cdef object on, oN
 *     try:
 */
  __pyx_v_n = PETSC_DECIDE;
  __pyx_v_N = PETSC_DECIDE;

  /* "SLEPc/slepcbv.pxi":126
 *     cdef PetscInt n=PETSC_DECIDE, N=PETSC_DECIDE
 *     cdef object on, oN
 *     try:             # <<<<<<<<<<<<<<
 *         on, oN = size
 *     except (TypeError, ValueError):
 */
  {
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
    __Pyx_XGOTREF(__pyx_t_1);
    __Pyx_XGOTREF(__pyx_t_2);
    __Pyx_XGOTREF(__pyx_t_3);
    /*try:*/ {

      /* "SLEPc/slepcbv.pxi":127
 *     cdef object on, oN
 *     try:
 *         on, oN = size             # <<<<<<<<<<<<<<
 *     except (TypeError, ValueError):
 *         on = None; oN = size
 */
      if ((likely(PyTuple_CheckExact(__pyx_v_size))) || (PyList_CheckExact(__pyx_v_size))) {
        PyObject* sequence = __pyx_v_size;
        Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
        if (unlikely(size != 2)) {
          if (size > 2) __Pyx_RaiseTooManyValuesError(2);
          else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
          __PYX_ERR(2, 127, __pyx_L3_error)
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        if (likely(PyTuple_CheckExact(sequence))) {
          __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); 
          __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); 
        } else {
          __pyx_t_4 = PyList_GET_ITEM(sequence, 0); 
          __pyx_t_5 = PyList_GET_ITEM(sequence, 1); 
        }
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_5);
        #else
        __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 127, __pyx_L3_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 127, __pyx_L3_error)
        __Pyx_GOTREF(__pyx_t_5);
        #endif
      } else {
        Py_ssize_t index = -1;
        __pyx_t_6 = PyObject_GetIter(__pyx_v_size); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 127, __pyx_L3_error)
        __Pyx_GOTREF(__pyx_t_6);
        __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext;
        index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L9_unpacking_failed;
        __Pyx_GOTREF(__pyx_t_4);
        index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L9_unpacking_failed;
        __Pyx_GOTREF(__pyx_t_5);
        if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) __PYX_ERR(2, 127, __pyx_L3_error)
        __pyx_t_7 = NULL;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        goto __pyx_L10_unpacking_done;
        __pyx_L9_unpacking_failed:;
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __pyx_t_7 = NULL;
        if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
        __PYX_ERR(2, 127, __pyx_L3_error)
        __pyx_L10_unpacking_done:;
      }
      __pyx_v_on = __pyx_t_4;
      __pyx_t_4 = 0;
      __pyx_v_oN = __pyx_t_5;
      __pyx_t_5 = 0;

      /* "SLEPc/slepcbv.pxi":126
 *     cdef PetscInt n=PETSC_DECIDE, N=PETSC_DECIDE
 *     cdef object on, oN
 *     try:             # <<<<<<<<<<<<<<
 *         on, oN = size
 *     except (TypeError, ValueError):
 */
    }
    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    goto __pyx_L8_try_end;
    __pyx_L3_error:;
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;

    /* "SLEPc/slepcbv.pxi":128
 *     try:
 *         on, oN = size
 *     except (TypeError, ValueError):             # <<<<<<<<<<<<<<
 *         on = None; oN = size
 *     if on is not None: n = asInt(on)
 */
    __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError);
    if (__pyx_t_8) {
      __Pyx_AddTraceback("slepc4py.SLEPc.BV_Sizes", __pyx_clineno, __pyx_lineno, __pyx_filename);
      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_6) < 0) __PYX_ERR(2, 128, __pyx_L5_except_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_GOTREF(__pyx_t_6);

      /* "SLEPc/slepcbv.pxi":129
 *         on, oN = size
 *     except (TypeError, ValueError):
 *         on = None; oN = size             # <<<<<<<<<<<<<<
 *     if on is not None: n = asInt(on)
 *     if oN is not None: N = asInt(oN)
 */
      __Pyx_INCREF(Py_None);
      __Pyx_XDECREF_SET(__pyx_v_on, Py_None);
      __Pyx_INCREF(__pyx_v_size);
      __Pyx_XDECREF_SET(__pyx_v_oN, __pyx_v_size);
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      goto __pyx_L4_exception_handled;
    }
    goto __pyx_L5_except_error;
    __pyx_L5_except_error:;

    /* "SLEPc/slepcbv.pxi":126
 *     cdef PetscInt n=PETSC_DECIDE, N=PETSC_DECIDE
 *     cdef object on, oN
 *     try:             # <<<<<<<<<<<<<<
 *         on, oN = size
 *     except (TypeError, ValueError):
 */
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    goto __pyx_L1_error;
    __pyx_L4_exception_handled:;
    __Pyx_XGIVEREF(__pyx_t_1);
    __Pyx_XGIVEREF(__pyx_t_2);
    __Pyx_XGIVEREF(__pyx_t_3);
    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
    __pyx_L8_try_end:;
  }

  /* "SLEPc/slepcbv.pxi":130
 *     except (TypeError, ValueError):
 *         on = None; oN = size
 *     if on is not None: n = asInt(on)             # <<<<<<<<<<<<<<
 *     if oN is not None: N = asInt(oN)
 *     if n==PETSC_DECIDE and N==PETSC_DECIDE: raise ValueError(
 */
  __pyx_t_9 = (__pyx_v_on != Py_None);
  __pyx_t_10 = (__pyx_t_9 != 0);
  if (__pyx_t_10) {
    __pyx_t_11 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_on); if (unlikely(__pyx_t_11 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(2, 130, __pyx_L1_error)
    __pyx_v_n = __pyx_t_11;
  }

  /* "SLEPc/slepcbv.pxi":131
 *         on = None; oN = size
 *     if on is not None: n = asInt(on)
 *     if oN is not None: N = asInt(oN)             # <<<<<<<<<<<<<<
 *     if n==PETSC_DECIDE and N==PETSC_DECIDE: raise ValueError(
 *         "local and global sizes cannot be both 'DECIDE'")
 */
  __pyx_t_10 = (__pyx_v_oN != Py_None);
  __pyx_t_9 = (__pyx_t_10 != 0);
  if (__pyx_t_9) {
    __pyx_t_11 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_oN); if (unlikely(__pyx_t_11 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(2, 131, __pyx_L1_error)
    __pyx_v_N = __pyx_t_11;
  }

  /* "SLEPc/slepcbv.pxi":132
 *     if on is not None: n = asInt(on)
 *     if oN is not None: N = asInt(oN)
 *     if n==PETSC_DECIDE and N==PETSC_DECIDE: raise ValueError(             # <<<<<<<<<<<<<<
 *         "local and global sizes cannot be both 'DECIDE'")
 *     # return result to the caller
 */
  __pyx_t_10 = ((__pyx_v_n == PETSC_DECIDE) != 0);
  if (__pyx_t_10) {
  } else {
    __pyx_t_9 = __pyx_t_10;
    goto __pyx_L16_bool_binop_done;
  }
  __pyx_t_10 = ((__pyx_v_N == PETSC_DECIDE) != 0);
  __pyx_t_9 = __pyx_t_10;
  __pyx_L16_bool_binop_done:;
  if (unlikely(__pyx_t_9)) {
    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 132, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_Raise(__pyx_t_6, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __PYX_ERR(2, 132, __pyx_L1_error)
  }

  /* "SLEPc/slepcbv.pxi":135
 *         "local and global sizes cannot be both 'DECIDE'")
 *     # return result to the caller
 *     if _n != NULL: _n[0] = n             # <<<<<<<<<<<<<<
 *     if _N != NULL: _N[0] = N
 *     return 0
 */
  __pyx_t_9 = ((__pyx_v__n != NULL) != 0);
  if (__pyx_t_9) {
    (__pyx_v__n[0]) = __pyx_v_n;
  }

  /* "SLEPc/slepcbv.pxi":136
 *     # return result to the caller
 *     if _n != NULL: _n[0] = n
 *     if _N != NULL: _N[0] = N             # <<<<<<<<<<<<<<
 *     return 0
 */
  __pyx_t_9 = ((__pyx_v__N != NULL) != 0);
  if (__pyx_t_9) {
    (__pyx_v__N[0]) = __pyx_v_N;
  }

  /* "SLEPc/slepcbv.pxi":137
 *     if _n != NULL: _n[0] = n
 *     if _N != NULL: _N[0] = N
 *     return 0             # <<<<<<<<<<<<<<
 */
  __pyx_r = 0;
  goto __pyx_L0;

  /* "SLEPc/slepcbv.pxi":118
 *     int BVRestoreMat(SlepcBV,PetscMat*)
 * 
 * cdef inline int BV_Sizes(             # <<<<<<<<<<<<<<
 *     object size,
 *     PetscInt *_n,
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV_Sizes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_on);
  __Pyx_XDECREF(__pyx_v_oN);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepceps.pxi":311
 * # -----------------------------------------------------------------------------
 * 
 * cdef inline EPS ref_EPS(SlepcEPS eps):             # <<<<<<<<<<<<<<
 *     cdef EPS ob = <EPS> EPS()
 *     ob.eps = eps
 */

static CYTHON_INLINE struct PySlepcEPSObject *__pyx_f_8slepc4py_5SLEPc_ref_EPS(EPS __pyx_v_eps) {
  struct PySlepcEPSObject *__pyx_v_ob = 0;
  struct PySlepcEPSObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ref_EPS", 0);

  /* "SLEPc/slepceps.pxi":312
 * 
 * cdef inline EPS ref_EPS(SlepcEPS eps):
 *     cdef EPS ob = <EPS> EPS()             # <<<<<<<<<<<<<<
 *     ob.eps = eps
 *     PetscINCREF(ob.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 312, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_t_1;
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_ob = ((struct PySlepcEPSObject *)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/slepceps.pxi":313
 * cdef inline EPS ref_EPS(SlepcEPS eps):
 *     cdef EPS ob = <EPS> EPS()
 *     ob.eps = eps             # <<<<<<<<<<<<<<
 *     PetscINCREF(ob.obj)
 *     return ob
 */
  __pyx_v_ob->eps = __pyx_v_eps;

  /* "SLEPc/slepceps.pxi":314
 *     cdef EPS ob = <EPS> EPS()
 *     ob.eps = eps
 *     PetscINCREF(ob.obj)             # <<<<<<<<<<<<<<
 *     return ob
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ob->__pyx_base.obj));

  /* "SLEPc/slepceps.pxi":315
 *     ob.eps = eps
 *     PetscINCREF(ob.obj)
 *     return ob             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ob));
  __pyx_r = __pyx_v_ob;
  goto __pyx_L0;

  /* "SLEPc/slepceps.pxi":311
 * # -----------------------------------------------------------------------------
 * 
 * cdef inline EPS ref_EPS(SlepcEPS eps):             # <<<<<<<<<<<<<<
 *     cdef EPS ob = <EPS> EPS()
 *     ob.eps = eps
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ref_EPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepceps.pxi":319
 * # -----------------------------------------------------------------------------
 * 
 * cdef int EPS_Stopping(             # <<<<<<<<<<<<<<
 *     SlepcEPS                eps,
 *     PetscInt                its,
 */

static int __pyx_f_8slepc4py_5SLEPc_EPS_Stopping(EPS __pyx_v_eps, PetscInt __pyx_v_its, PetscInt __pyx_v_max_it, PetscInt __pyx_v_nconv, PetscInt __pyx_v_nev, EPSConvergedReason *__pyx_v_r, CYTHON_UNUSED void *__pyx_v_ctx) {
  struct PySlepcEPSObject *__pyx_v_Eps = 0;
  PyObject *__pyx_v_stopping = NULL;
  PyObject *__pyx_v_args = NULL;
  PyObject *__pyx_v_kargs = NULL;
  PyObject *__pyx_v_reason = NULL;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *(*__pyx_t_6)(PyObject *);
  int __pyx_t_7;
  int __pyx_t_8;
  EPSConvergedReason __pyx_t_9;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  #ifdef WITH_THREAD
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_RefNannySetupContext("EPS_Stopping", 0);

  /* "SLEPc/slepceps.pxi":328
 *     void                    *ctx,
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef EPS Eps = ref_EPS(eps)             # <<<<<<<<<<<<<<
 *     (stopping, args, kargs) = Eps.get_attr('__stopping__')
 *     reason = stopping(Eps, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_EPS(__pyx_v_eps)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 328, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Eps = ((struct PySlepcEPSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepceps.pxi":329
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef EPS Eps = ref_EPS(eps)
 *     (stopping, args, kargs) = Eps.get_attr('__stopping__')             # <<<<<<<<<<<<<<
 *     reason = stopping(Eps, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 *     if   reason is None:  r[0] = EPS_CONVERGED_ITERATING
 */
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_Eps->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_Eps), ((char *)"__stopping__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 329, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
    PyObject* sequence = __pyx_t_1;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 3)) {
      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(3, 329, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); 
    } else {
      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyList_GET_ITEM(sequence, 2); 
    }
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_4);
    #else
    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 329, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 329, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 329, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    #endif
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 329, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
    index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_2);
    index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_3);
    index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(3, 329, __pyx_L1_error)
    __pyx_t_6 = NULL;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L4_unpacking_done;
    __pyx_L3_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(3, 329, __pyx_L1_error)
    __pyx_L4_unpacking_done:;
  }
  __pyx_v_stopping = __pyx_t_2;
  __pyx_t_2 = 0;
  __pyx_v_args = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_kargs = __pyx_t_4;
  __pyx_t_4 = 0;

  /* "SLEPc/slepceps.pxi":330
 *     cdef EPS Eps = ref_EPS(eps)
 *     (stopping, args, kargs) = Eps.get_attr('__stopping__')
 *     reason = stopping(Eps, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)             # <<<<<<<<<<<<<<
 *     if   reason is None:  r[0] = EPS_CONVERGED_ITERATING
 *     elif reason is False: r[0] = EPS_CONVERGED_ITERATING
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_its); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_max_it); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_nconv); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_nev); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_INCREF(((PyObject *)__pyx_v_Eps));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_Eps));
  PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_Eps));
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_t_2);
  __pyx_t_1 = 0;
  __pyx_t_4 = 0;
  __pyx_t_3 = 0;
  __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Add(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(__pyx_v_kargs == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
    __PYX_ERR(3, 330, __pyx_L1_error)
  }
  if (likely(PyDict_CheckExact(__pyx_v_kargs))) {
    __pyx_t_2 = PyDict_Copy(__pyx_v_kargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 330, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  } else {
    __pyx_t_2 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_v_kargs, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 330, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_v_stopping, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_reason = __pyx_t_5;
  __pyx_t_5 = 0;

  /* "SLEPc/slepceps.pxi":331
 *     (stopping, args, kargs) = Eps.get_attr('__stopping__')
 *     reason = stopping(Eps, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 *     if   reason is None:  r[0] = EPS_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *     elif reason is False: r[0] = EPS_CONVERGED_ITERATING
 *     elif reason is True:  r[0] = EPS_CONVERGED_USER
 */
  __pyx_t_7 = (__pyx_v_reason == Py_None);
  __pyx_t_8 = (__pyx_t_7 != 0);
  if (__pyx_t_8) {
    (__pyx_v_r[0]) = EPS_CONVERGED_ITERATING;
    goto __pyx_L5;
  }

  /* "SLEPc/slepceps.pxi":332
 *     reason = stopping(Eps, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 *     if   reason is None:  r[0] = EPS_CONVERGED_ITERATING
 *     elif reason is False: r[0] = EPS_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *     elif reason is True:  r[0] = EPS_CONVERGED_USER
 *     else:                 r[0] = reason
 */
  __pyx_t_8 = (__pyx_v_reason == Py_False);
  __pyx_t_7 = (__pyx_t_8 != 0);
  if (__pyx_t_7) {
    (__pyx_v_r[0]) = EPS_CONVERGED_ITERATING;
    goto __pyx_L5;
  }

  /* "SLEPc/slepceps.pxi":333
 *     if   reason is None:  r[0] = EPS_CONVERGED_ITERATING
 *     elif reason is False: r[0] = EPS_CONVERGED_ITERATING
 *     elif reason is True:  r[0] = EPS_CONVERGED_USER             # <<<<<<<<<<<<<<
 *     else:                 r[0] = reason
 * 
 */
  __pyx_t_7 = (__pyx_v_reason == Py_True);
  __pyx_t_8 = (__pyx_t_7 != 0);
  if (__pyx_t_8) {
    (__pyx_v_r[0]) = EPS_CONVERGED_USER;
    goto __pyx_L5;
  }

  /* "SLEPc/slepceps.pxi":334
 *     elif reason is False: r[0] = EPS_CONVERGED_ITERATING
 *     elif reason is True:  r[0] = EPS_CONVERGED_USER
 *     else:                 r[0] = reason             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  /*else*/ {
    __pyx_t_9 = ((EPSConvergedReason)__Pyx_PyInt_As_EPSConvergedReason(__pyx_v_reason)); if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 334, __pyx_L1_error)
    (__pyx_v_r[0]) = __pyx_t_9;
  }
  __pyx_L5:;

  /* "SLEPc/slepceps.pxi":319
 * # -----------------------------------------------------------------------------
 * 
 * cdef int EPS_Stopping(             # <<<<<<<<<<<<<<
 *     SlepcEPS                eps,
 *     PetscInt                its,
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS_Stopping", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = PETSC_ERR_PYTHON;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_Eps);
  __Pyx_XDECREF(__pyx_v_stopping);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XDECREF(__pyx_v_reason);
  __Pyx_RefNannyFinishContext();
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  return __pyx_r;
}

/* "SLEPc/slepceps.pxi":338
 * # -----------------------------------------------------------------------------
 * 
 * cdef int EPS_Arbitrary(             # <<<<<<<<<<<<<<
 *     PetscScalar  er,
 *     PetscScalar  ei,
 */

static int __pyx_f_8slepc4py_5SLEPc_EPS_Arbitrary(PetscScalar __pyx_v_er, PetscScalar __pyx_v_ei, Vec __pyx_v_xr, Vec __pyx_v_xi, PetscScalar *__pyx_v_rr, PetscScalar *__pyx_v_ri, void *__pyx_v_ctx) {
  PyObject *__pyx_v_arbitrary = NULL;
  PyObject *__pyx_v_args = NULL;
  PyObject *__pyx_v_kargs = NULL;
  struct PyPetscVecObject *__pyx_v_Vr = 0;
  struct PyPetscVecObject *__pyx_v_Vi = 0;
  PyObject *__pyx_v_r = NULL;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *(*__pyx_t_6)(PyObject *);
  int __pyx_t_7;
  PetscReal __pyx_t_8;
  PetscScalar __pyx_t_9;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  #ifdef WITH_THREAD
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_RefNannySetupContext("EPS_Arbitrary", 0);

  /* "SLEPc/slepceps.pxi":347
 *     void         *ctx,
 *     ) except PETSC_ERR_PYTHON with gil:
 *     (arbitrary, args, kargs) = <object>ctx             # <<<<<<<<<<<<<<
 *     cdef Vec Vr = ref_Vec(xr)
 *     cdef Vec Vi = ref_Vec(xi)
 */
  __pyx_t_1 = ((PyObject *)__pyx_v_ctx);
  __Pyx_INCREF(__pyx_t_1);
  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
    PyObject* sequence = __pyx_t_1;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 3)) {
      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(3, 347, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); 
    } else {
      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyList_GET_ITEM(sequence, 2); 
    }
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_4);
    #else
    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 347, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 347, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 347, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    #endif
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 347, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
    index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_2);
    index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_3);
    index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(3, 347, __pyx_L1_error)
    __pyx_t_6 = NULL;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L4_unpacking_done;
    __pyx_L3_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(3, 347, __pyx_L1_error)
    __pyx_L4_unpacking_done:;
  }
  __pyx_v_arbitrary = __pyx_t_2;
  __pyx_t_2 = 0;
  __pyx_v_args = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_kargs = __pyx_t_4;
  __pyx_t_4 = 0;

  /* "SLEPc/slepceps.pxi":348
 *     ) except PETSC_ERR_PYTHON with gil:
 *     (arbitrary, args, kargs) = <object>ctx
 *     cdef Vec Vr = ref_Vec(xr)             # <<<<<<<<<<<<<<
 *     cdef Vec Vi = ref_Vec(xi)
 *     r = arbitrary(toComplex(er,ei), Vr, Vi, args, **kargs)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_Vec(__pyx_v_xr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Vr = ((struct PyPetscVecObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepceps.pxi":349
 *     (arbitrary, args, kargs) = <object>ctx
 *     cdef Vec Vr = ref_Vec(xr)
 *     cdef Vec Vi = ref_Vec(xi)             # <<<<<<<<<<<<<<
 *     r = arbitrary(toComplex(er,ei), Vr, Vi, args, **kargs)
 *     if sizeof(PetscScalar) == sizeof(PetscReal):
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_Vec(__pyx_v_xi)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Vi = ((struct PyPetscVecObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepceps.pxi":350
 *     cdef Vec Vr = ref_Vec(xr)
 *     cdef Vec Vi = ref_Vec(xi)
 *     r = arbitrary(toComplex(er,ei), Vr, Vi, args, **kargs)             # <<<<<<<<<<<<<<
 *     if sizeof(PetscScalar) == sizeof(PetscReal):
 *         rr[0] = asComplexReal(r)
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_toComplex(__pyx_v_er, __pyx_v_ei); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
  __Pyx_INCREF(((PyObject *)__pyx_v_Vr));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_Vr));
  PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_Vr));
  __Pyx_INCREF(((PyObject *)__pyx_v_Vi));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_Vi));
  PyTuple_SET_ITEM(__pyx_t_4, 2, ((PyObject *)__pyx_v_Vi));
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_GIVEREF(__pyx_v_args);
  PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_args);
  __pyx_t_1 = 0;
  if (unlikely(__pyx_v_kargs == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
    __PYX_ERR(3, 350, __pyx_L1_error)
  }
  if (likely(PyDict_CheckExact(__pyx_v_kargs))) {
    __pyx_t_1 = PyDict_Copy(__pyx_v_kargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 350, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  } else {
    __pyx_t_1 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_v_kargs, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 350, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_v_arbitrary, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_r = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/slepceps.pxi":351
 *     cdef Vec Vi = ref_Vec(xi)
 *     r = arbitrary(toComplex(er,ei), Vr, Vi, args, **kargs)
 *     if sizeof(PetscScalar) == sizeof(PetscReal):             # <<<<<<<<<<<<<<
 *         rr[0] = asComplexReal(r)
 *         ri[0] = asComplexImag(r)
 */
  __pyx_t_7 = (((sizeof(PetscScalar)) == (sizeof(PetscReal))) != 0);
  if (__pyx_t_7) {

    /* "SLEPc/slepceps.pxi":352
 *     r = arbitrary(toComplex(er,ei), Vr, Vi, args, **kargs)
 *     if sizeof(PetscScalar) == sizeof(PetscReal):
 *         rr[0] = asComplexReal(r)             # <<<<<<<<<<<<<<
 *         ri[0] = asComplexImag(r)
 *     else:
 */
    __pyx_t_8 = __pyx_f_8slepc4py_5SLEPc_asComplexReal(__pyx_v_r); if (unlikely(__pyx_t_8 == ((PetscReal)((PetscReal)(-1.0))) && PyErr_Occurred())) __PYX_ERR(3, 352, __pyx_L1_error)
    (__pyx_v_rr[0]) = __pyx_t_8;

    /* "SLEPc/slepceps.pxi":353
 *     if sizeof(PetscScalar) == sizeof(PetscReal):
 *         rr[0] = asComplexReal(r)
 *         ri[0] = asComplexImag(r)             # <<<<<<<<<<<<<<
 *     else:
 *         rr[0] = asScalar(r)
 */
    __pyx_t_8 = __pyx_f_8slepc4py_5SLEPc_asComplexImag(__pyx_v_r); if (unlikely(__pyx_t_8 == ((PetscReal)((PetscReal)(-1.0))) && PyErr_Occurred())) __PYX_ERR(3, 353, __pyx_L1_error)
    (__pyx_v_ri[0]) = __pyx_t_8;

    /* "SLEPc/slepceps.pxi":351
 *     cdef Vec Vi = ref_Vec(xi)
 *     r = arbitrary(toComplex(er,ei), Vr, Vi, args, **kargs)
 *     if sizeof(PetscScalar) == sizeof(PetscReal):             # <<<<<<<<<<<<<<
 *         rr[0] = asComplexReal(r)
 *         ri[0] = asComplexImag(r)
 */
    goto __pyx_L5;
  }

  /* "SLEPc/slepceps.pxi":355
 *         ri[0] = asComplexImag(r)
 *     else:
 *         rr[0] = asScalar(r)             # <<<<<<<<<<<<<<
 *         ri[0] = 0.0
 * 
 */
  /*else*/ {
    __pyx_t_9 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_r); if (unlikely(__pyx_t_9 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(3, 355, __pyx_L1_error)
    (__pyx_v_rr[0]) = __pyx_t_9;

    /* "SLEPc/slepceps.pxi":356
 *     else:
 *         rr[0] = asScalar(r)
 *         ri[0] = 0.0             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
    (__pyx_v_ri[0]) = 0.0;
  }
  __pyx_L5:;

  /* "SLEPc/slepceps.pxi":338
 * # -----------------------------------------------------------------------------
 * 
 * cdef int EPS_Arbitrary(             # <<<<<<<<<<<<<<
 *     PetscScalar  er,
 *     PetscScalar  ei,
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS_Arbitrary", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = PETSC_ERR_PYTHON;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_arbitrary);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XDECREF((PyObject *)__pyx_v_Vr);
  __Pyx_XDECREF((PyObject *)__pyx_v_Vi);
  __Pyx_XDECREF(__pyx_v_r);
  __Pyx_RefNannyFinishContext();
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  return __pyx_r;
}

/* "SLEPc/slepceps.pxi":360
 * # -----------------------------------------------------------------------------
 * 
 * cdef int EPS_Comparison(             # <<<<<<<<<<<<<<
 *     PetscScalar  ar,
 *     PetscScalar  ai,
 */

static int __pyx_f_8slepc4py_5SLEPc_EPS_Comparison(PetscScalar __pyx_v_ar, PetscScalar __pyx_v_ai, PetscScalar __pyx_v_br, PetscScalar __pyx_v_bi, PetscInt *__pyx_v_res, void *__pyx_v_ctx) {
  PyObject *__pyx_v_comparison = NULL;
  PyObject *__pyx_v_args = NULL;
  PyObject *__pyx_v_kargs = NULL;
  PyObject *__pyx_v_r = NULL;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *(*__pyx_t_6)(PyObject *);
  PetscInt __pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  #ifdef WITH_THREAD
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_RefNannySetupContext("EPS_Comparison", 0);

  /* "SLEPc/slepceps.pxi":368
 *     void         *ctx,
 *     ) except PETSC_ERR_PYTHON with gil:
 *     (comparison, args, kargs) = <object>ctx             # <<<<<<<<<<<<<<
 *     r = comparison(toComplex(ar, ai), toComplex(br, bi), args, **kargs)
 *     res[0] = asInt(r)
 */
  __pyx_t_1 = ((PyObject *)__pyx_v_ctx);
  __Pyx_INCREF(__pyx_t_1);
  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
    PyObject* sequence = __pyx_t_1;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 3)) {
      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(3, 368, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); 
    } else {
      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyList_GET_ITEM(sequence, 2); 
    }
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_4);
    #else
    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 368, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 368, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 368, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    #endif
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 368, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
    index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_2);
    index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_3);
    index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(3, 368, __pyx_L1_error)
    __pyx_t_6 = NULL;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L4_unpacking_done;
    __pyx_L3_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(3, 368, __pyx_L1_error)
    __pyx_L4_unpacking_done:;
  }
  __pyx_v_comparison = __pyx_t_2;
  __pyx_t_2 = 0;
  __pyx_v_args = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_kargs = __pyx_t_4;
  __pyx_t_4 = 0;

  /* "SLEPc/slepceps.pxi":369
 *     ) except PETSC_ERR_PYTHON with gil:
 *     (comparison, args, kargs) = <object>ctx
 *     r = comparison(toComplex(ar, ai), toComplex(br, bi), args, **kargs)             # <<<<<<<<<<<<<<
 *     res[0] = asInt(r)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_toComplex(__pyx_v_ar, __pyx_v_ai); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 369, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toComplex(__pyx_v_br, __pyx_v_bi); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 369, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 369, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_GIVEREF(__pyx_v_args);
  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_args);
  __pyx_t_1 = 0;
  __pyx_t_4 = 0;
  if (unlikely(__pyx_v_kargs == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
    __PYX_ERR(3, 369, __pyx_L1_error)
  }
  if (likely(PyDict_CheckExact(__pyx_v_kargs))) {
    __pyx_t_4 = PyDict_Copy(__pyx_v_kargs); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 369, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  } else {
    __pyx_t_4 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_v_kargs, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 369, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
  }
  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_v_comparison, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 369, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_r = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/slepceps.pxi":370
 *     (comparison, args, kargs) = <object>ctx
 *     r = comparison(toComplex(ar, ai), toComplex(br, bi), args, **kargs)
 *     res[0] = asInt(r)             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_r); if (unlikely(__pyx_t_7 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(3, 370, __pyx_L1_error)
  (__pyx_v_res[0]) = __pyx_t_7;

  /* "SLEPc/slepceps.pxi":360
 * # -----------------------------------------------------------------------------
 * 
 * cdef int EPS_Comparison(             # <<<<<<<<<<<<<<
 *     PetscScalar  ar,
 *     PetscScalar  ai,
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS_Comparison", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = PETSC_ERR_PYTHON;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_comparison);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XDECREF(__pyx_v_r);
  __Pyx_RefNannyFinishContext();
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  return __pyx_r;
}

/* "SLEPc/slepceps.pxi":374
 * # -----------------------------------------------------------------------------
 * 
 * cdef int EPS_Monitor(             # <<<<<<<<<<<<<<
 *     SlepcEPS    eps,
 *     PetscInt    its,
 */

static int __pyx_f_8slepc4py_5SLEPc_EPS_Monitor(EPS __pyx_v_eps, PetscInt __pyx_v_its, PetscInt __pyx_v_nconv, PetscScalar *__pyx_v_eigr, PetscScalar *__pyx_v_eigi, PetscReal *__pyx_v_errest, PetscInt __pyx_v_nest, CYTHON_UNUSED void *__pyx_v_ctx) {
  struct PySlepcEPSObject *__pyx_v_Eps = 0;
  PyObject *__pyx_v_monitorlist = 0;
  PyObject *__pyx_v_eig = 0;
  PyObject *__pyx_v_err = 0;
  PyObject *__pyx_v_monitor = NULL;
  PyObject *__pyx_v_args = NULL;
  PyObject *__pyx_v_kargs = NULL;
  PetscInt __pyx_7genexpr__pyx_v_i;
  PetscInt __pyx_8genexpr1__pyx_v_i;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_t_3;
  PetscInt __pyx_t_4;
  PetscInt __pyx_t_5;
  PetscInt __pyx_t_6;
  PyObject *__pyx_t_7 = NULL;
  Py_ssize_t __pyx_t_8;
  PyObject *(*__pyx_t_9)(PyObject *);
  PyObject *__pyx_t_10 = NULL;
  PyObject *__pyx_t_11 = NULL;
  PyObject *__pyx_t_12 = NULL;
  PyObject *__pyx_t_13 = NULL;
  PyObject *(*__pyx_t_14)(PyObject *);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  #ifdef WITH_THREAD
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_RefNannySetupContext("EPS_Monitor", 0);

  /* "SLEPc/slepceps.pxi":384
 *     void        *ctx,
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef EPS Eps = ref_EPS(eps)             # <<<<<<<<<<<<<<
 *     cdef object monitorlist = Eps.get_attr('__monitor__')
 *     if monitorlist is None: return 0
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_EPS(__pyx_v_eps)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 384, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Eps = ((struct PySlepcEPSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepceps.pxi":385
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef EPS Eps = ref_EPS(eps)
 *     cdef object monitorlist = Eps.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 *     if monitorlist is None: return 0
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 */
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_Eps->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_Eps), ((char *)"__monitor__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 385, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_monitorlist = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/slepceps.pxi":386
 *     cdef EPS Eps = ref_EPS(eps)
 *     cdef object monitorlist = Eps.get_attr('__monitor__')
 *     if monitorlist is None: return 0             # <<<<<<<<<<<<<<
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 */
  __pyx_t_2 = (__pyx_v_monitorlist == Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_r = 0;
    goto __pyx_L0;
  }

  /* "SLEPc/slepceps.pxi":387
 *     cdef object monitorlist = Eps.get_attr('__monitor__')
 *     if monitorlist is None: return 0
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]             # <<<<<<<<<<<<<<
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:
 */
  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 387, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __pyx_v_nest;
    __pyx_t_5 = __pyx_t_4;
    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
      __pyx_7genexpr__pyx_v_i = __pyx_t_6;
      __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toComplex((__pyx_v_eigr[__pyx_7genexpr__pyx_v_i]), (__pyx_v_eigi[__pyx_7genexpr__pyx_v_i])); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 387, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(3, 387, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    }
  } /* exit inner scope */
  __pyx_v_eig = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/slepceps.pxi":388
 *     if monitorlist is None: return 0
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]             # <<<<<<<<<<<<<<
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Eps, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 */
  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 388, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __pyx_v_nest;
    __pyx_t_5 = __pyx_t_4;
    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
      __pyx_8genexpr1__pyx_v_i = __pyx_t_6;
      __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toReal((__pyx_v_errest[__pyx_8genexpr1__pyx_v_i])); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 388, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(3, 388, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    }
  } /* exit inner scope */
  __pyx_v_err = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/slepceps.pxi":389
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:             # <<<<<<<<<<<<<<
 *         monitor(Eps, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 *     return 0
 */
  if (likely(PyList_CheckExact(__pyx_v_monitorlist)) || PyTuple_CheckExact(__pyx_v_monitorlist)) {
    __pyx_t_1 = __pyx_v_monitorlist; __Pyx_INCREF(__pyx_t_1); __pyx_t_8 = 0;
    __pyx_t_9 = NULL;
  } else {
    __pyx_t_8 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_monitorlist); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 389, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_9 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 389, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_9)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_7 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(3, 389, __pyx_L1_error)
        #else
        __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 389, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        #endif
      } else {
        if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(3, 389, __pyx_L1_error)
        #else
        __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 389, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        #endif
      }
    } else {
      __pyx_t_7 = __pyx_t_9(__pyx_t_1);
      if (unlikely(!__pyx_t_7)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(3, 389, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_7);
    }
    if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) {
      PyObject* sequence = __pyx_t_7;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 3)) {
        if (size > 3) __Pyx_RaiseTooManyValuesError(3);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(3, 389, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_10 = PyTuple_GET_ITEM(sequence, 0); 
        __pyx_t_11 = PyTuple_GET_ITEM(sequence, 1); 
        __pyx_t_12 = PyTuple_GET_ITEM(sequence, 2); 
      } else {
        __pyx_t_10 = PyList_GET_ITEM(sequence, 0); 
        __pyx_t_11 = PyList_GET_ITEM(sequence, 1); 
        __pyx_t_12 = PyList_GET_ITEM(sequence, 2); 
      }
      __Pyx_INCREF(__pyx_t_10);
      __Pyx_INCREF(__pyx_t_11);
      __Pyx_INCREF(__pyx_t_12);
      #else
      __pyx_t_10 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 389, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_11 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 389, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_12 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 389, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      #endif
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_13 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_13)) __PYX_ERR(3, 389, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_14 = Py_TYPE(__pyx_t_13)->tp_iternext;
      index = 0; __pyx_t_10 = __pyx_t_14(__pyx_t_13); if (unlikely(!__pyx_t_10)) goto __pyx_L10_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_10);
      index = 1; __pyx_t_11 = __pyx_t_14(__pyx_t_13); if (unlikely(!__pyx_t_11)) goto __pyx_L10_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_11);
      index = 2; __pyx_t_12 = __pyx_t_14(__pyx_t_13); if (unlikely(!__pyx_t_12)) goto __pyx_L10_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_12);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_13), 3) < 0) __PYX_ERR(3, 389, __pyx_L1_error)
      __pyx_t_14 = NULL;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      goto __pyx_L11_unpacking_done;
      __pyx_L10_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_14 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(3, 389, __pyx_L1_error)
      __pyx_L11_unpacking_done:;
    }
    __Pyx_XDECREF_SET(__pyx_v_monitor, __pyx_t_10);
    __pyx_t_10 = 0;
    __Pyx_XDECREF_SET(__pyx_v_args, __pyx_t_11);
    __pyx_t_11 = 0;
    __Pyx_XDECREF_SET(__pyx_v_kargs, __pyx_t_12);
    __pyx_t_12 = 0;

    /* "SLEPc/slepceps.pxi":390
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Eps, toInt(its), toInt(nconv), eig, err, *args, **kargs)             # <<<<<<<<<<<<<<
 *     return 0
 * 
 */
    __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_its); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_12 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_nconv); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_11 = PyTuple_New(5); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_INCREF(((PyObject *)__pyx_v_Eps));
    __Pyx_GIVEREF(((PyObject *)__pyx_v_Eps));
    PyTuple_SET_ITEM(__pyx_t_11, 0, ((PyObject *)__pyx_v_Eps));
    __Pyx_GIVEREF(__pyx_t_7);
    PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_7);
    __Pyx_GIVEREF(__pyx_t_12);
    PyTuple_SET_ITEM(__pyx_t_11, 2, __pyx_t_12);
    __Pyx_INCREF(__pyx_v_eig);
    __Pyx_GIVEREF(__pyx_v_eig);
    PyTuple_SET_ITEM(__pyx_t_11, 3, __pyx_v_eig);
    __Pyx_INCREF(__pyx_v_err);
    __Pyx_GIVEREF(__pyx_v_err);
    PyTuple_SET_ITEM(__pyx_t_11, 4, __pyx_v_err);
    __pyx_t_7 = 0;
    __pyx_t_12 = 0;
    __pyx_t_12 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_7 = PyNumber_Add(__pyx_t_11, __pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    if (unlikely(__pyx_v_kargs == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
      __PYX_ERR(3, 390, __pyx_L1_error)
    }
    if (likely(PyDict_CheckExact(__pyx_v_kargs))) {
      __pyx_t_12 = PyDict_Copy(__pyx_v_kargs); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 390, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
    } else {
      __pyx_t_12 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_v_kargs, NULL); if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 390, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
    }
    __pyx_t_11 = __Pyx_PyObject_Call(__pyx_v_monitor, __pyx_t_7, __pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 390, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;

    /* "SLEPc/slepceps.pxi":389
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:             # <<<<<<<<<<<<<<
 *         monitor(Eps, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 *     return 0
 */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/slepceps.pxi":391
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Eps, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 *     return 0             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = 0;
  goto __pyx_L0;

  /* "SLEPc/slepceps.pxi":374
 * # -----------------------------------------------------------------------------
 * 
 * cdef int EPS_Monitor(             # <<<<<<<<<<<<<<
 *     SlepcEPS    eps,
 *     PetscInt    its,
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS_Monitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = PETSC_ERR_PYTHON;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_Eps);
  __Pyx_XDECREF(__pyx_v_monitorlist);
  __Pyx_XDECREF(__pyx_v_eig);
  __Pyx_XDECREF(__pyx_v_err);
  __Pyx_XDECREF(__pyx_v_monitor);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_RefNannyFinishContext();
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  return __pyx_r;
}

/* "SLEPc/slepcsvd.pxi":154
 * # -----------------------------------------------------------------------------
 * 
 * cdef inline SVD ref_SVD(SlepcSVD svd):             # <<<<<<<<<<<<<<
 *     cdef SVD ob = <SVD> SVD()
 *     ob.svd = svd
 */

static CYTHON_INLINE struct PySlepcSVDObject *__pyx_f_8slepc4py_5SLEPc_ref_SVD(SVD __pyx_v_svd) {
  struct PySlepcSVDObject *__pyx_v_ob = 0;
  struct PySlepcSVDObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ref_SVD", 0);

  /* "SLEPc/slepcsvd.pxi":155
 * 
 * cdef inline SVD ref_SVD(SlepcSVD svd):
 *     cdef SVD ob = <SVD> SVD()             # <<<<<<<<<<<<<<
 *     ob.svd = svd
 *     PetscINCREF(ob.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_SVD)); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 155, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_t_1;
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_ob = ((struct PySlepcSVDObject *)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/slepcsvd.pxi":156
 * cdef inline SVD ref_SVD(SlepcSVD svd):
 *     cdef SVD ob = <SVD> SVD()
 *     ob.svd = svd             # <<<<<<<<<<<<<<
 *     PetscINCREF(ob.obj)
 *     return ob
 */
  __pyx_v_ob->svd = __pyx_v_svd;

  /* "SLEPc/slepcsvd.pxi":157
 *     cdef SVD ob = <SVD> SVD()
 *     ob.svd = svd
 *     PetscINCREF(ob.obj)             # <<<<<<<<<<<<<<
 *     return ob
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ob->__pyx_base.obj));

  /* "SLEPc/slepcsvd.pxi":158
 *     ob.svd = svd
 *     PetscINCREF(ob.obj)
 *     return ob             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ob));
  __pyx_r = __pyx_v_ob;
  goto __pyx_L0;

  /* "SLEPc/slepcsvd.pxi":154
 * # -----------------------------------------------------------------------------
 * 
 * cdef inline SVD ref_SVD(SlepcSVD svd):             # <<<<<<<<<<<<<<
 *     cdef SVD ob = <SVD> SVD()
 *     ob.svd = svd
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ref_SVD", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepcsvd.pxi":162
 * # -----------------------------------------------------------------------------
 * 
 * cdef int SVD_Stopping(             # <<<<<<<<<<<<<<
 *     SlepcSVD                svd,
 *     PetscInt                its,
 */

static int __pyx_f_8slepc4py_5SLEPc_SVD_Stopping(SVD __pyx_v_svd, PetscInt __pyx_v_its, PetscInt __pyx_v_max_it, PetscInt __pyx_v_nconv, PetscInt __pyx_v_nev, SVDConvergedReason *__pyx_v_r, CYTHON_UNUSED void *__pyx_v_ctx) {
  struct PySlepcSVDObject *__pyx_v_Svd = 0;
  PyObject *__pyx_v_stopping = NULL;
  PyObject *__pyx_v_args = NULL;
  PyObject *__pyx_v_kargs = NULL;
  PyObject *__pyx_v_reason = NULL;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *(*__pyx_t_6)(PyObject *);
  int __pyx_t_7;
  int __pyx_t_8;
  SVDConvergedReason __pyx_t_9;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  #ifdef WITH_THREAD
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_RefNannySetupContext("SVD_Stopping", 0);

  /* "SLEPc/slepcsvd.pxi":171
 *     void                    *ctx,
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef SVD Svd = ref_SVD(svd)             # <<<<<<<<<<<<<<
 *     (stopping, args, kargs) = Svd.get_attr('__stopping__')
 *     reason = stopping(Svd, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_SVD(__pyx_v_svd)); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 171, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Svd = ((struct PySlepcSVDObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepcsvd.pxi":172
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef SVD Svd = ref_SVD(svd)
 *     (stopping, args, kargs) = Svd.get_attr('__stopping__')             # <<<<<<<<<<<<<<
 *     reason = stopping(Svd, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 *     if   reason is None:  r[0] = SVD_CONVERGED_ITERATING
 */
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_SVD *)__pyx_v_Svd->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_Svd), ((char *)"__stopping__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
    PyObject* sequence = __pyx_t_1;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 3)) {
      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(8, 172, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); 
    } else {
      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyList_GET_ITEM(sequence, 2); 
    }
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_4);
    #else
    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 172, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 172, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 172, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    #endif
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(8, 172, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
    index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_2);
    index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_3);
    index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(8, 172, __pyx_L1_error)
    __pyx_t_6 = NULL;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L4_unpacking_done;
    __pyx_L3_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(8, 172, __pyx_L1_error)
    __pyx_L4_unpacking_done:;
  }
  __pyx_v_stopping = __pyx_t_2;
  __pyx_t_2 = 0;
  __pyx_v_args = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_kargs = __pyx_t_4;
  __pyx_t_4 = 0;

  /* "SLEPc/slepcsvd.pxi":173
 *     cdef SVD Svd = ref_SVD(svd)
 *     (stopping, args, kargs) = Svd.get_attr('__stopping__')
 *     reason = stopping(Svd, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)             # <<<<<<<<<<<<<<
 *     if   reason is None:  r[0] = SVD_CONVERGED_ITERATING
 *     elif reason is False: r[0] = SVD_CONVERGED_ITERATING
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_its); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_max_it); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_nconv); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_nev); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(8, 173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_INCREF(((PyObject *)__pyx_v_Svd));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_Svd));
  PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_Svd));
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_t_2);
  __pyx_t_1 = 0;
  __pyx_t_4 = 0;
  __pyx_t_3 = 0;
  __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Add(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(__pyx_v_kargs == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
    __PYX_ERR(8, 173, __pyx_L1_error)
  }
  if (likely(PyDict_CheckExact(__pyx_v_kargs))) {
    __pyx_t_2 = PyDict_Copy(__pyx_v_kargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 173, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  } else {
    __pyx_t_2 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_v_kargs, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 173, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_v_stopping, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(8, 173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_reason = __pyx_t_5;
  __pyx_t_5 = 0;

  /* "SLEPc/slepcsvd.pxi":174
 *     (stopping, args, kargs) = Svd.get_attr('__stopping__')
 *     reason = stopping(Svd, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 *     if   reason is None:  r[0] = SVD_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *     elif reason is False: r[0] = SVD_CONVERGED_ITERATING
 *     elif reason is True:  r[0] = SVD_CONVERGED_USER
 */
  __pyx_t_7 = (__pyx_v_reason == Py_None);
  __pyx_t_8 = (__pyx_t_7 != 0);
  if (__pyx_t_8) {
    (__pyx_v_r[0]) = SVD_CONVERGED_ITERATING;
    goto __pyx_L5;
  }

  /* "SLEPc/slepcsvd.pxi":175
 *     reason = stopping(Svd, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 *     if   reason is None:  r[0] = SVD_CONVERGED_ITERATING
 *     elif reason is False: r[0] = SVD_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *     elif reason is True:  r[0] = SVD_CONVERGED_USER
 *     else:                 r[0] = reason
 */
  __pyx_t_8 = (__pyx_v_reason == Py_False);
  __pyx_t_7 = (__pyx_t_8 != 0);
  if (__pyx_t_7) {
    (__pyx_v_r[0]) = SVD_CONVERGED_ITERATING;
    goto __pyx_L5;
  }

  /* "SLEPc/slepcsvd.pxi":176
 *     if   reason is None:  r[0] = SVD_CONVERGED_ITERATING
 *     elif reason is False: r[0] = SVD_CONVERGED_ITERATING
 *     elif reason is True:  r[0] = SVD_CONVERGED_USER             # <<<<<<<<<<<<<<
 *     else:                 r[0] = reason
 * 
 */
  __pyx_t_7 = (__pyx_v_reason == Py_True);
  __pyx_t_8 = (__pyx_t_7 != 0);
  if (__pyx_t_8) {
    (__pyx_v_r[0]) = SVD_CONVERGED_USER;
    goto __pyx_L5;
  }

  /* "SLEPc/slepcsvd.pxi":177
 *     elif reason is False: r[0] = SVD_CONVERGED_ITERATING
 *     elif reason is True:  r[0] = SVD_CONVERGED_USER
 *     else:                 r[0] = reason             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  /*else*/ {
    __pyx_t_9 = ((SVDConvergedReason)__Pyx_PyInt_As_SVDConvergedReason(__pyx_v_reason)); if (unlikely(PyErr_Occurred())) __PYX_ERR(8, 177, __pyx_L1_error)
    (__pyx_v_r[0]) = __pyx_t_9;
  }
  __pyx_L5:;

  /* "SLEPc/slepcsvd.pxi":162
 * # -----------------------------------------------------------------------------
 * 
 * cdef int SVD_Stopping(             # <<<<<<<<<<<<<<
 *     SlepcSVD                svd,
 *     PetscInt                its,
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD_Stopping", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = PETSC_ERR_PYTHON;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_Svd);
  __Pyx_XDECREF(__pyx_v_stopping);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XDECREF(__pyx_v_reason);
  __Pyx_RefNannyFinishContext();
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  return __pyx_r;
}

/* "SLEPc/slepcsvd.pxi":181
 * # -----------------------------------------------------------------------------
 * 
 * cdef int SVD_Monitor(             # <<<<<<<<<<<<<<
 *     SlepcSVD    svd,
 *     PetscInt    its,
 */

static int __pyx_f_8slepc4py_5SLEPc_SVD_Monitor(SVD __pyx_v_svd, PetscInt __pyx_v_its, PetscInt __pyx_v_nconv, PetscReal *__pyx_v_sigma, PetscReal *__pyx_v_errest, PetscInt __pyx_v_nest, CYTHON_UNUSED void *__pyx_v_ctx) {
  struct PySlepcSVDObject *__pyx_v_Svd = 0;
  PyObject *__pyx_v_monitorlist = 0;
  PyObject *__pyx_v_eig = 0;
  PyObject *__pyx_v_err = 0;
  PyObject *__pyx_v_monitor = NULL;
  PyObject *__pyx_v_args = NULL;
  PyObject *__pyx_v_kargs = NULL;
  PetscInt __pyx_8genexpr2__pyx_v_i;
  PetscInt __pyx_8genexpr3__pyx_v_i;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_t_3;
  PetscInt __pyx_t_4;
  PetscInt __pyx_t_5;
  PetscInt __pyx_t_6;
  PyObject *__pyx_t_7 = NULL;
  Py_ssize_t __pyx_t_8;
  PyObject *(*__pyx_t_9)(PyObject *);
  PyObject *__pyx_t_10 = NULL;
  PyObject *__pyx_t_11 = NULL;
  PyObject *__pyx_t_12 = NULL;
  PyObject *__pyx_t_13 = NULL;
  PyObject *(*__pyx_t_14)(PyObject *);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  #ifdef WITH_THREAD
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_RefNannySetupContext("SVD_Monitor", 0);

  /* "SLEPc/slepcsvd.pxi":190
 *     void        *ctx,
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef SVD Svd = ref_SVD(svd)             # <<<<<<<<<<<<<<
 *     cdef object monitorlist = Svd.get_attr('__monitor__')
 *     if monitorlist is None: return 0
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_SVD(__pyx_v_svd)); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 190, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Svd = ((struct PySlepcSVDObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepcsvd.pxi":191
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef SVD Svd = ref_SVD(svd)
 *     cdef object monitorlist = Svd.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 *     if monitorlist is None: return 0
 *     cdef object eig = [toReal(sigma[i]) for i in range(nest)]
 */
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_SVD *)__pyx_v_Svd->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_Svd), ((char *)"__monitor__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_monitorlist = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/slepcsvd.pxi":192
 *     cdef SVD Svd = ref_SVD(svd)
 *     cdef object monitorlist = Svd.get_attr('__monitor__')
 *     if monitorlist is None: return 0             # <<<<<<<<<<<<<<
 *     cdef object eig = [toReal(sigma[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 */
  __pyx_t_2 = (__pyx_v_monitorlist == Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_r = 0;
    goto __pyx_L0;
  }

  /* "SLEPc/slepcsvd.pxi":193
 *     cdef object monitorlist = Svd.get_attr('__monitor__')
 *     if monitorlist is None: return 0
 *     cdef object eig = [toReal(sigma[i]) for i in range(nest)]             # <<<<<<<<<<<<<<
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:
 */
  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 193, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __pyx_v_nest;
    __pyx_t_5 = __pyx_t_4;
    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
      __pyx_8genexpr2__pyx_v_i = __pyx_t_6;
      __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toReal((__pyx_v_sigma[__pyx_8genexpr2__pyx_v_i])); if (unlikely(!__pyx_t_7)) __PYX_ERR(8, 193, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(8, 193, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    }
  } /* exit inner scope */
  __pyx_v_eig = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/slepcsvd.pxi":194
 *     if monitorlist is None: return 0
 *     cdef object eig = [toReal(sigma[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]             # <<<<<<<<<<<<<<
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Svd, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 */
  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 194, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __pyx_v_nest;
    __pyx_t_5 = __pyx_t_4;
    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
      __pyx_8genexpr3__pyx_v_i = __pyx_t_6;
      __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toReal((__pyx_v_errest[__pyx_8genexpr3__pyx_v_i])); if (unlikely(!__pyx_t_7)) __PYX_ERR(8, 194, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(8, 194, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    }
  } /* exit inner scope */
  __pyx_v_err = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/slepcsvd.pxi":195
 *     cdef object eig = [toReal(sigma[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:             # <<<<<<<<<<<<<<
 *         monitor(Svd, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 *     return 0
 */
  if (likely(PyList_CheckExact(__pyx_v_monitorlist)) || PyTuple_CheckExact(__pyx_v_monitorlist)) {
    __pyx_t_1 = __pyx_v_monitorlist; __Pyx_INCREF(__pyx_t_1); __pyx_t_8 = 0;
    __pyx_t_9 = NULL;
  } else {
    __pyx_t_8 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_monitorlist); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 195, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_9 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(8, 195, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_9)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_7 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(8, 195, __pyx_L1_error)
        #else
        __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(8, 195, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        #endif
      } else {
        if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(8, 195, __pyx_L1_error)
        #else
        __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(8, 195, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        #endif
      }
    } else {
      __pyx_t_7 = __pyx_t_9(__pyx_t_1);
      if (unlikely(!__pyx_t_7)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(8, 195, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_7);
    }
    if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) {
      PyObject* sequence = __pyx_t_7;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 3)) {
        if (size > 3) __Pyx_RaiseTooManyValuesError(3);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(8, 195, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_10 = PyTuple_GET_ITEM(sequence, 0); 
        __pyx_t_11 = PyTuple_GET_ITEM(sequence, 1); 
        __pyx_t_12 = PyTuple_GET_ITEM(sequence, 2); 
      } else {
        __pyx_t_10 = PyList_GET_ITEM(sequence, 0); 
        __pyx_t_11 = PyList_GET_ITEM(sequence, 1); 
        __pyx_t_12 = PyList_GET_ITEM(sequence, 2); 
      }
      __Pyx_INCREF(__pyx_t_10);
      __Pyx_INCREF(__pyx_t_11);
      __Pyx_INCREF(__pyx_t_12);
      #else
      __pyx_t_10 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(8, 195, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_11 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(8, 195, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_12 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_12)) __PYX_ERR(8, 195, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      #endif
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_13 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_13)) __PYX_ERR(8, 195, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_14 = Py_TYPE(__pyx_t_13)->tp_iternext;
      index = 0; __pyx_t_10 = __pyx_t_14(__pyx_t_13); if (unlikely(!__pyx_t_10)) goto __pyx_L10_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_10);
      index = 1; __pyx_t_11 = __pyx_t_14(__pyx_t_13); if (unlikely(!__pyx_t_11)) goto __pyx_L10_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_11);
      index = 2; __pyx_t_12 = __pyx_t_14(__pyx_t_13); if (unlikely(!__pyx_t_12)) goto __pyx_L10_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_12);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_13), 3) < 0) __PYX_ERR(8, 195, __pyx_L1_error)
      __pyx_t_14 = NULL;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      goto __pyx_L11_unpacking_done;
      __pyx_L10_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_14 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(8, 195, __pyx_L1_error)
      __pyx_L11_unpacking_done:;
    }
    __Pyx_XDECREF_SET(__pyx_v_monitor, __pyx_t_10);
    __pyx_t_10 = 0;
    __Pyx_XDECREF_SET(__pyx_v_args, __pyx_t_11);
    __pyx_t_11 = 0;
    __Pyx_XDECREF_SET(__pyx_v_kargs, __pyx_t_12);
    __pyx_t_12 = 0;

    /* "SLEPc/slepcsvd.pxi":196
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Svd, toInt(its), toInt(nconv), eig, err, *args, **kargs)             # <<<<<<<<<<<<<<
 *     return 0
 * 
 */
    __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_its); if (unlikely(!__pyx_t_7)) __PYX_ERR(8, 196, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_12 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_nconv); if (unlikely(!__pyx_t_12)) __PYX_ERR(8, 196, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_11 = PyTuple_New(5); if (unlikely(!__pyx_t_11)) __PYX_ERR(8, 196, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_INCREF(((PyObject *)__pyx_v_Svd));
    __Pyx_GIVEREF(((PyObject *)__pyx_v_Svd));
    PyTuple_SET_ITEM(__pyx_t_11, 0, ((PyObject *)__pyx_v_Svd));
    __Pyx_GIVEREF(__pyx_t_7);
    PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_7);
    __Pyx_GIVEREF(__pyx_t_12);
    PyTuple_SET_ITEM(__pyx_t_11, 2, __pyx_t_12);
    __Pyx_INCREF(__pyx_v_eig);
    __Pyx_GIVEREF(__pyx_v_eig);
    PyTuple_SET_ITEM(__pyx_t_11, 3, __pyx_v_eig);
    __Pyx_INCREF(__pyx_v_err);
    __Pyx_GIVEREF(__pyx_v_err);
    PyTuple_SET_ITEM(__pyx_t_11, 4, __pyx_v_err);
    __pyx_t_7 = 0;
    __pyx_t_12 = 0;
    __pyx_t_12 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_12)) __PYX_ERR(8, 196, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_7 = PyNumber_Add(__pyx_t_11, __pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(8, 196, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    if (unlikely(__pyx_v_kargs == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
      __PYX_ERR(8, 196, __pyx_L1_error)
    }
    if (likely(PyDict_CheckExact(__pyx_v_kargs))) {
      __pyx_t_12 = PyDict_Copy(__pyx_v_kargs); if (unlikely(!__pyx_t_12)) __PYX_ERR(8, 196, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
    } else {
      __pyx_t_12 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_v_kargs, NULL); if (unlikely(!__pyx_t_12)) __PYX_ERR(8, 196, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
    }
    __pyx_t_11 = __Pyx_PyObject_Call(__pyx_v_monitor, __pyx_t_7, __pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(8, 196, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;

    /* "SLEPc/slepcsvd.pxi":195
 *     cdef object eig = [toReal(sigma[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:             # <<<<<<<<<<<<<<
 *         monitor(Svd, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 *     return 0
 */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/slepcsvd.pxi":197
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Svd, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 *     return 0             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = 0;
  goto __pyx_L0;

  /* "SLEPc/slepcsvd.pxi":181
 * # -----------------------------------------------------------------------------
 * 
 * cdef int SVD_Monitor(             # <<<<<<<<<<<<<<
 *     SlepcSVD    svd,
 *     PetscInt    its,
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD_Monitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = PETSC_ERR_PYTHON;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_Svd);
  __Pyx_XDECREF(__pyx_v_monitorlist);
  __Pyx_XDECREF(__pyx_v_eig);
  __Pyx_XDECREF(__pyx_v_err);
  __Pyx_XDECREF(__pyx_v_monitor);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_RefNannyFinishContext();
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  return __pyx_r;
}

/* "SLEPc/slepcpep.pxi":233
 * # -----------------------------------------------------------------------------
 * 
 * cdef inline PEP ref_PEP(SlepcPEP pep):             # <<<<<<<<<<<<<<
 *     cdef PEP ob = <PEP> PEP()
 *     ob.pep = pep
 */

static CYTHON_INLINE struct PySlepcPEPObject *__pyx_f_8slepc4py_5SLEPc_ref_PEP(PEP __pyx_v_pep) {
  struct PySlepcPEPObject *__pyx_v_ob = 0;
  struct PySlepcPEPObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ref_PEP", 0);

  /* "SLEPc/slepcpep.pxi":234
 * 
 * cdef inline PEP ref_PEP(SlepcPEP pep):
 *     cdef PEP ob = <PEP> PEP()             # <<<<<<<<<<<<<<
 *     ob.pep = pep
 *     PetscINCREF(ob.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_t_1;
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_ob = ((struct PySlepcPEPObject *)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/slepcpep.pxi":235
 * cdef inline PEP ref_PEP(SlepcPEP pep):
 *     cdef PEP ob = <PEP> PEP()
 *     ob.pep = pep             # <<<<<<<<<<<<<<
 *     PetscINCREF(ob.obj)
 *     return ob
 */
  __pyx_v_ob->pep = __pyx_v_pep;

  /* "SLEPc/slepcpep.pxi":236
 *     cdef PEP ob = <PEP> PEP()
 *     ob.pep = pep
 *     PetscINCREF(ob.obj)             # <<<<<<<<<<<<<<
 *     return ob
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ob->__pyx_base.obj));

  /* "SLEPc/slepcpep.pxi":237
 *     ob.pep = pep
 *     PetscINCREF(ob.obj)
 *     return ob             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ob));
  __pyx_r = __pyx_v_ob;
  goto __pyx_L0;

  /* "SLEPc/slepcpep.pxi":233
 * # -----------------------------------------------------------------------------
 * 
 * cdef inline PEP ref_PEP(SlepcPEP pep):             # <<<<<<<<<<<<<<
 *     cdef PEP ob = <PEP> PEP()
 *     ob.pep = pep
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ref_PEP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepcpep.pxi":241
 * # -----------------------------------------------------------------------------
 * 
 * cdef int PEP_Stopping(             # <<<<<<<<<<<<<<
 *     SlepcPEP                pep,
 *     PetscInt                its,
 */

static int __pyx_f_8slepc4py_5SLEPc_PEP_Stopping(PEP __pyx_v_pep, PetscInt __pyx_v_its, PetscInt __pyx_v_max_it, PetscInt __pyx_v_nconv, PetscInt __pyx_v_nev, PEPConvergedReason *__pyx_v_r, CYTHON_UNUSED void *__pyx_v_ctx) {
  struct PySlepcPEPObject *__pyx_v_Pep = 0;
  PyObject *__pyx_v_stopping = NULL;
  PyObject *__pyx_v_args = NULL;
  PyObject *__pyx_v_kargs = NULL;
  PyObject *__pyx_v_reason = NULL;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *(*__pyx_t_6)(PyObject *);
  int __pyx_t_7;
  int __pyx_t_8;
  PEPConvergedReason __pyx_t_9;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  #ifdef WITH_THREAD
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_RefNannySetupContext("PEP_Stopping", 0);

  /* "SLEPc/slepcpep.pxi":250
 *     void                    *ctx,
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef PEP Pep = ref_PEP(pep)             # <<<<<<<<<<<<<<
 *     (stopping, args, kargs) = Pep.get_attr('__stopping__')
 *     reason = stopping(Pep, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_PEP(__pyx_v_pep)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 250, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Pep = ((struct PySlepcPEPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepcpep.pxi":251
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef PEP Pep = ref_PEP(pep)
 *     (stopping, args, kargs) = Pep.get_attr('__stopping__')             # <<<<<<<<<<<<<<
 *     reason = stopping(Pep, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 *     if   reason is None:  r[0] = PEP_CONVERGED_ITERATING
 */
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_PEP *)__pyx_v_Pep->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_Pep), ((char *)"__stopping__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
    PyObject* sequence = __pyx_t_1;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 3)) {
      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(9, 251, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); 
    } else {
      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyList_GET_ITEM(sequence, 2); 
    }
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_4);
    #else
    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 251, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 251, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 251, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    #endif
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 251, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
    index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_2);
    index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_3);
    index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(9, 251, __pyx_L1_error)
    __pyx_t_6 = NULL;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L4_unpacking_done;
    __pyx_L3_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(9, 251, __pyx_L1_error)
    __pyx_L4_unpacking_done:;
  }
  __pyx_v_stopping = __pyx_t_2;
  __pyx_t_2 = 0;
  __pyx_v_args = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_kargs = __pyx_t_4;
  __pyx_t_4 = 0;

  /* "SLEPc/slepcpep.pxi":252
 *     cdef PEP Pep = ref_PEP(pep)
 *     (stopping, args, kargs) = Pep.get_attr('__stopping__')
 *     reason = stopping(Pep, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)             # <<<<<<<<<<<<<<
 *     if   reason is None:  r[0] = PEP_CONVERGED_ITERATING
 *     elif reason is False: r[0] = PEP_CONVERGED_ITERATING
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_its); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 252, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_max_it); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 252, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_nconv); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 252, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_nev); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 252, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 252, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_INCREF(((PyObject *)__pyx_v_Pep));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_Pep));
  PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_Pep));
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_t_2);
  __pyx_t_1 = 0;
  __pyx_t_4 = 0;
  __pyx_t_3 = 0;
  __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 252, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Add(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 252, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(__pyx_v_kargs == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
    __PYX_ERR(9, 252, __pyx_L1_error)
  }
  if (likely(PyDict_CheckExact(__pyx_v_kargs))) {
    __pyx_t_2 = PyDict_Copy(__pyx_v_kargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 252, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  } else {
    __pyx_t_2 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_v_kargs, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 252, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_v_stopping, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 252, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_reason = __pyx_t_5;
  __pyx_t_5 = 0;

  /* "SLEPc/slepcpep.pxi":253
 *     (stopping, args, kargs) = Pep.get_attr('__stopping__')
 *     reason = stopping(Pep, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 *     if   reason is None:  r[0] = PEP_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *     elif reason is False: r[0] = PEP_CONVERGED_ITERATING
 *     elif reason is True:  r[0] = PEP_CONVERGED_USER
 */
  __pyx_t_7 = (__pyx_v_reason == Py_None);
  __pyx_t_8 = (__pyx_t_7 != 0);
  if (__pyx_t_8) {
    (__pyx_v_r[0]) = PEP_CONVERGED_ITERATING;
    goto __pyx_L5;
  }

  /* "SLEPc/slepcpep.pxi":254
 *     reason = stopping(Pep, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 *     if   reason is None:  r[0] = PEP_CONVERGED_ITERATING
 *     elif reason is False: r[0] = PEP_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *     elif reason is True:  r[0] = PEP_CONVERGED_USER
 *     else:                 r[0] = reason
 */
  __pyx_t_8 = (__pyx_v_reason == Py_False);
  __pyx_t_7 = (__pyx_t_8 != 0);
  if (__pyx_t_7) {
    (__pyx_v_r[0]) = PEP_CONVERGED_ITERATING;
    goto __pyx_L5;
  }

  /* "SLEPc/slepcpep.pxi":255
 *     if   reason is None:  r[0] = PEP_CONVERGED_ITERATING
 *     elif reason is False: r[0] = PEP_CONVERGED_ITERATING
 *     elif reason is True:  r[0] = PEP_CONVERGED_USER             # <<<<<<<<<<<<<<
 *     else:                 r[0] = reason
 * 
 */
  __pyx_t_7 = (__pyx_v_reason == Py_True);
  __pyx_t_8 = (__pyx_t_7 != 0);
  if (__pyx_t_8) {
    (__pyx_v_r[0]) = PEP_CONVERGED_USER;
    goto __pyx_L5;
  }

  /* "SLEPc/slepcpep.pxi":256
 *     elif reason is False: r[0] = PEP_CONVERGED_ITERATING
 *     elif reason is True:  r[0] = PEP_CONVERGED_USER
 *     else:                 r[0] = reason             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  /*else*/ {
    __pyx_t_9 = ((PEPConvergedReason)__Pyx_PyInt_As_PEPConvergedReason(__pyx_v_reason)); if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 256, __pyx_L1_error)
    (__pyx_v_r[0]) = __pyx_t_9;
  }
  __pyx_L5:;

  /* "SLEPc/slepcpep.pxi":241
 * # -----------------------------------------------------------------------------
 * 
 * cdef int PEP_Stopping(             # <<<<<<<<<<<<<<
 *     SlepcPEP                pep,
 *     PetscInt                its,
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP_Stopping", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = PETSC_ERR_PYTHON;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_Pep);
  __Pyx_XDECREF(__pyx_v_stopping);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XDECREF(__pyx_v_reason);
  __Pyx_RefNannyFinishContext();
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  return __pyx_r;
}

/* "SLEPc/slepcpep.pxi":260
 * # -----------------------------------------------------------------------------
 * 
 * cdef int PEP_Monitor(             # <<<<<<<<<<<<<<
 *     SlepcPEP    pep,
 *     PetscInt    its,
 */

static int __pyx_f_8slepc4py_5SLEPc_PEP_Monitor(PEP __pyx_v_pep, PetscInt __pyx_v_its, PetscInt __pyx_v_nconv, PetscScalar *__pyx_v_eigr, PetscScalar *__pyx_v_eigi, PetscReal *__pyx_v_errest, PetscInt __pyx_v_nest, CYTHON_UNUSED void *__pyx_v_ctx) {
  struct PySlepcPEPObject *__pyx_v_Pep = 0;
  PyObject *__pyx_v_monitorlist = 0;
  PyObject *__pyx_v_eig = 0;
  PyObject *__pyx_v_err = 0;
  PyObject *__pyx_v_monitor = NULL;
  PyObject *__pyx_v_args = NULL;
  PyObject *__pyx_v_kargs = NULL;
  PetscInt __pyx_8genexpr4__pyx_v_i;
  PetscInt __pyx_8genexpr5__pyx_v_i;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_t_3;
  PetscInt __pyx_t_4;
  PetscInt __pyx_t_5;
  PetscInt __pyx_t_6;
  PyObject *__pyx_t_7 = NULL;
  Py_ssize_t __pyx_t_8;
  PyObject *(*__pyx_t_9)(PyObject *);
  PyObject *__pyx_t_10 = NULL;
  PyObject *__pyx_t_11 = NULL;
  PyObject *__pyx_t_12 = NULL;
  PyObject *__pyx_t_13 = NULL;
  PyObject *(*__pyx_t_14)(PyObject *);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  #ifdef WITH_THREAD
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_RefNannySetupContext("PEP_Monitor", 0);

  /* "SLEPc/slepcpep.pxi":270
 *     void        *ctx,
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef PEP Pep = ref_PEP(pep)             # <<<<<<<<<<<<<<
 *     cdef object monitorlist = Pep.get_attr('__monitor__')
 *     if monitorlist is None: return 0
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_PEP(__pyx_v_pep)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 270, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Pep = ((struct PySlepcPEPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepcpep.pxi":271
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef PEP Pep = ref_PEP(pep)
 *     cdef object monitorlist = Pep.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 *     if monitorlist is None: return 0
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 */
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_PEP *)__pyx_v_Pep->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_Pep), ((char *)"__monitor__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 271, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_monitorlist = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/slepcpep.pxi":272
 *     cdef PEP Pep = ref_PEP(pep)
 *     cdef object monitorlist = Pep.get_attr('__monitor__')
 *     if monitorlist is None: return 0             # <<<<<<<<<<<<<<
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 */
  __pyx_t_2 = (__pyx_v_monitorlist == Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_r = 0;
    goto __pyx_L0;
  }

  /* "SLEPc/slepcpep.pxi":273
 *     cdef object monitorlist = Pep.get_attr('__monitor__')
 *     if monitorlist is None: return 0
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]             # <<<<<<<<<<<<<<
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:
 */
  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 273, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __pyx_v_nest;
    __pyx_t_5 = __pyx_t_4;
    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
      __pyx_8genexpr4__pyx_v_i = __pyx_t_6;
      __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toComplex((__pyx_v_eigr[__pyx_8genexpr4__pyx_v_i]), (__pyx_v_eigi[__pyx_8genexpr4__pyx_v_i])); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 273, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(9, 273, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    }
  } /* exit inner scope */
  __pyx_v_eig = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/slepcpep.pxi":274
 *     if monitorlist is None: return 0
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]             # <<<<<<<<<<<<<<
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Pep, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 */
  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 274, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __pyx_v_nest;
    __pyx_t_5 = __pyx_t_4;
    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
      __pyx_8genexpr5__pyx_v_i = __pyx_t_6;
      __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toReal((__pyx_v_errest[__pyx_8genexpr5__pyx_v_i])); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 274, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(9, 274, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    }
  } /* exit inner scope */
  __pyx_v_err = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/slepcpep.pxi":275
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:             # <<<<<<<<<<<<<<
 *         monitor(Pep, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 *     return 0
 */
  if (likely(PyList_CheckExact(__pyx_v_monitorlist)) || PyTuple_CheckExact(__pyx_v_monitorlist)) {
    __pyx_t_1 = __pyx_v_monitorlist; __Pyx_INCREF(__pyx_t_1); __pyx_t_8 = 0;
    __pyx_t_9 = NULL;
  } else {
    __pyx_t_8 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_monitorlist); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 275, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_9 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(9, 275, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_9)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_7 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(9, 275, __pyx_L1_error)
        #else
        __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 275, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        #endif
      } else {
        if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(9, 275, __pyx_L1_error)
        #else
        __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 275, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        #endif
      }
    } else {
      __pyx_t_7 = __pyx_t_9(__pyx_t_1);
      if (unlikely(!__pyx_t_7)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(9, 275, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_7);
    }
    if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) {
      PyObject* sequence = __pyx_t_7;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 3)) {
        if (size > 3) __Pyx_RaiseTooManyValuesError(3);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(9, 275, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_10 = PyTuple_GET_ITEM(sequence, 0); 
        __pyx_t_11 = PyTuple_GET_ITEM(sequence, 1); 
        __pyx_t_12 = PyTuple_GET_ITEM(sequence, 2); 
      } else {
        __pyx_t_10 = PyList_GET_ITEM(sequence, 0); 
        __pyx_t_11 = PyList_GET_ITEM(sequence, 1); 
        __pyx_t_12 = PyList_GET_ITEM(sequence, 2); 
      }
      __Pyx_INCREF(__pyx_t_10);
      __Pyx_INCREF(__pyx_t_11);
      __Pyx_INCREF(__pyx_t_12);
      #else
      __pyx_t_10 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(9, 275, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_11 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(9, 275, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_12 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_12)) __PYX_ERR(9, 275, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      #endif
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_13 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_13)) __PYX_ERR(9, 275, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_14 = Py_TYPE(__pyx_t_13)->tp_iternext;
      index = 0; __pyx_t_10 = __pyx_t_14(__pyx_t_13); if (unlikely(!__pyx_t_10)) goto __pyx_L10_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_10);
      index = 1; __pyx_t_11 = __pyx_t_14(__pyx_t_13); if (unlikely(!__pyx_t_11)) goto __pyx_L10_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_11);
      index = 2; __pyx_t_12 = __pyx_t_14(__pyx_t_13); if (unlikely(!__pyx_t_12)) goto __pyx_L10_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_12);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_13), 3) < 0) __PYX_ERR(9, 275, __pyx_L1_error)
      __pyx_t_14 = NULL;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      goto __pyx_L11_unpacking_done;
      __pyx_L10_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_14 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(9, 275, __pyx_L1_error)
      __pyx_L11_unpacking_done:;
    }
    __Pyx_XDECREF_SET(__pyx_v_monitor, __pyx_t_10);
    __pyx_t_10 = 0;
    __Pyx_XDECREF_SET(__pyx_v_args, __pyx_t_11);
    __pyx_t_11 = 0;
    __Pyx_XDECREF_SET(__pyx_v_kargs, __pyx_t_12);
    __pyx_t_12 = 0;

    /* "SLEPc/slepcpep.pxi":276
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Pep, toInt(its), toInt(nconv), eig, err, *args, **kargs)             # <<<<<<<<<<<<<<
 *     return 0
 * 
 */
    __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_its); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 276, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_12 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_nconv); if (unlikely(!__pyx_t_12)) __PYX_ERR(9, 276, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_11 = PyTuple_New(5); if (unlikely(!__pyx_t_11)) __PYX_ERR(9, 276, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_INCREF(((PyObject *)__pyx_v_Pep));
    __Pyx_GIVEREF(((PyObject *)__pyx_v_Pep));
    PyTuple_SET_ITEM(__pyx_t_11, 0, ((PyObject *)__pyx_v_Pep));
    __Pyx_GIVEREF(__pyx_t_7);
    PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_7);
    __Pyx_GIVEREF(__pyx_t_12);
    PyTuple_SET_ITEM(__pyx_t_11, 2, __pyx_t_12);
    __Pyx_INCREF(__pyx_v_eig);
    __Pyx_GIVEREF(__pyx_v_eig);
    PyTuple_SET_ITEM(__pyx_t_11, 3, __pyx_v_eig);
    __Pyx_INCREF(__pyx_v_err);
    __Pyx_GIVEREF(__pyx_v_err);
    PyTuple_SET_ITEM(__pyx_t_11, 4, __pyx_v_err);
    __pyx_t_7 = 0;
    __pyx_t_12 = 0;
    __pyx_t_12 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_12)) __PYX_ERR(9, 276, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_7 = PyNumber_Add(__pyx_t_11, __pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 276, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    if (unlikely(__pyx_v_kargs == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
      __PYX_ERR(9, 276, __pyx_L1_error)
    }
    if (likely(PyDict_CheckExact(__pyx_v_kargs))) {
      __pyx_t_12 = PyDict_Copy(__pyx_v_kargs); if (unlikely(!__pyx_t_12)) __PYX_ERR(9, 276, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
    } else {
      __pyx_t_12 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_v_kargs, NULL); if (unlikely(!__pyx_t_12)) __PYX_ERR(9, 276, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
    }
    __pyx_t_11 = __Pyx_PyObject_Call(__pyx_v_monitor, __pyx_t_7, __pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(9, 276, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;

    /* "SLEPc/slepcpep.pxi":275
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:             # <<<<<<<<<<<<<<
 *         monitor(Pep, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 *     return 0
 */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/slepcpep.pxi":277
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Pep, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 *     return 0             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = 0;
  goto __pyx_L0;

  /* "SLEPc/slepcpep.pxi":260
 * # -----------------------------------------------------------------------------
 * 
 * cdef int PEP_Monitor(             # <<<<<<<<<<<<<<
 *     SlepcPEP    pep,
 *     PetscInt    its,
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP_Monitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = PETSC_ERR_PYTHON;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_Pep);
  __Pyx_XDECREF(__pyx_v_monitorlist);
  __Pyx_XDECREF(__pyx_v_eig);
  __Pyx_XDECREF(__pyx_v_err);
  __Pyx_XDECREF(__pyx_v_monitor);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_RefNannyFinishContext();
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  return __pyx_r;
}

/* "SLEPc/slepcnep.pxi":229
 * # -----------------------------------------------------------------------------
 * 
 * cdef inline NEP ref_NEP(SlepcNEP nep):             # <<<<<<<<<<<<<<
 *     cdef NEP ob = <NEP> NEP()
 *     ob.nep = nep
 */

static CYTHON_INLINE struct PySlepcNEPObject *__pyx_f_8slepc4py_5SLEPc_ref_NEP(NEP __pyx_v_nep) {
  struct PySlepcNEPObject *__pyx_v_ob = 0;
  struct PySlepcNEPObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ref_NEP", 0);

  /* "SLEPc/slepcnep.pxi":230
 * 
 * cdef inline NEP ref_NEP(SlepcNEP nep):
 *     cdef NEP ob = <NEP> NEP()             # <<<<<<<<<<<<<<
 *     ob.nep = nep
 *     PetscINCREF(ob.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_NEP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 230, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_t_1;
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_ob = ((struct PySlepcNEPObject *)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/slepcnep.pxi":231
 * cdef inline NEP ref_NEP(SlepcNEP nep):
 *     cdef NEP ob = <NEP> NEP()
 *     ob.nep = nep             # <<<<<<<<<<<<<<
 *     PetscINCREF(ob.obj)
 *     return ob
 */
  __pyx_v_ob->nep = __pyx_v_nep;

  /* "SLEPc/slepcnep.pxi":232
 *     cdef NEP ob = <NEP> NEP()
 *     ob.nep = nep
 *     PetscINCREF(ob.obj)             # <<<<<<<<<<<<<<
 *     return ob
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ob->__pyx_base.obj));

  /* "SLEPc/slepcnep.pxi":233
 *     ob.nep = nep
 *     PetscINCREF(ob.obj)
 *     return ob             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ob));
  __pyx_r = __pyx_v_ob;
  goto __pyx_L0;

  /* "SLEPc/slepcnep.pxi":229
 * # -----------------------------------------------------------------------------
 * 
 * cdef inline NEP ref_NEP(SlepcNEP nep):             # <<<<<<<<<<<<<<
 *     cdef NEP ob = <NEP> NEP()
 *     ob.nep = nep
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ref_NEP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepcnep.pxi":237
 * # -----------------------------------------------------------------------------
 * 
 * cdef int NEP_Function(             # <<<<<<<<<<<<<<
 *     SlepcNEP    nep,
 *     PetscScalar mu,
 */

static int __pyx_f_8slepc4py_5SLEPc_NEP_Function(NEP __pyx_v_nep, PetscScalar __pyx_v_mu, Mat __pyx_v_A, Mat __pyx_v_B, CYTHON_UNUSED void *__pyx_v_ctx) {
  struct PySlepcNEPObject *__pyx_v_Nep = 0;
  struct PyPetscMatObject *__pyx_v_Amat = 0;
  struct PyPetscMatObject *__pyx_v_Bmat = 0;
  PyObject *__pyx_v_function = NULL;
  PyObject *__pyx_v_args = NULL;
  PyObject *__pyx_v_kargs = NULL;
  CYTHON_UNUSED PyObject *__pyx_v_retv = NULL;
  Mat __pyx_v_Atmp;
  Mat __pyx_v_Btmp;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *(*__pyx_t_6)(PyObject *);
  Mat __pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  #ifdef WITH_THREAD
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_RefNannySetupContext("NEP_Function", 0);

  /* "SLEPc/slepcnep.pxi":244
 *     void*       ctx,
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef NEP Nep  = ref_NEP(nep)             # <<<<<<<<<<<<<<
 *     cdef Mat Amat = ref_Mat(A)
 *     cdef Mat Bmat = ref_Mat(B)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_NEP(__pyx_v_nep)); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 244, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Nep = ((struct PySlepcNEPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepcnep.pxi":245
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef NEP Nep  = ref_NEP(nep)
 *     cdef Mat Amat = ref_Mat(A)             # <<<<<<<<<<<<<<
 *     cdef Mat Bmat = ref_Mat(B)
 *     (function, args, kargs) = Nep.get_attr('__function__')
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_Mat(__pyx_v_A)); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 245, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Amat = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepcnep.pxi":246
 *     cdef NEP Nep  = ref_NEP(nep)
 *     cdef Mat Amat = ref_Mat(A)
 *     cdef Mat Bmat = ref_Mat(B)             # <<<<<<<<<<<<<<
 *     (function, args, kargs) = Nep.get_attr('__function__')
 *     retv = function(Nep, toScalar(mu), Amat, Bmat, *args, **kargs)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_Mat(__pyx_v_B)); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 246, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Bmat = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepcnep.pxi":247
 *     cdef Mat Amat = ref_Mat(A)
 *     cdef Mat Bmat = ref_Mat(B)
 *     (function, args, kargs) = Nep.get_attr('__function__')             # <<<<<<<<<<<<<<
 *     retv = function(Nep, toScalar(mu), Amat, Bmat, *args, **kargs)
 *     cdef PetscMat Atmp = NULL, Btmp = NULL
 */
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_Nep->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_Nep), ((char *)"__function__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 247, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
    PyObject* sequence = __pyx_t_1;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 3)) {
      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(10, 247, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); 
    } else {
      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyList_GET_ITEM(sequence, 2); 
    }
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_4);
    #else
    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 247, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(10, 247, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(10, 247, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    #endif
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(10, 247, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
    index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_2);
    index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_3);
    index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(10, 247, __pyx_L1_error)
    __pyx_t_6 = NULL;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L4_unpacking_done;
    __pyx_L3_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(10, 247, __pyx_L1_error)
    __pyx_L4_unpacking_done:;
  }
  __pyx_v_function = __pyx_t_2;
  __pyx_t_2 = 0;
  __pyx_v_args = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_kargs = __pyx_t_4;
  __pyx_t_4 = 0;

  /* "SLEPc/slepcnep.pxi":248
 *     cdef Mat Bmat = ref_Mat(B)
 *     (function, args, kargs) = Nep.get_attr('__function__')
 *     retv = function(Nep, toScalar(mu), Amat, Bmat, *args, **kargs)             # <<<<<<<<<<<<<<
 *     cdef PetscMat Atmp = NULL, Btmp = NULL
 *     Atmp = A; A = Amat.mat; Amat.mat = Atmp
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_mu); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 248, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(10, 248, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(((PyObject *)__pyx_v_Nep));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_Nep));
  PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_Nep));
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
  __Pyx_INCREF(((PyObject *)__pyx_v_Amat));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_Amat));
  PyTuple_SET_ITEM(__pyx_t_4, 2, ((PyObject *)__pyx_v_Amat));
  __Pyx_INCREF(((PyObject *)__pyx_v_Bmat));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_Bmat));
  PyTuple_SET_ITEM(__pyx_t_4, 3, ((PyObject *)__pyx_v_Bmat));
  __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 248, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyNumber_Add(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(10, 248, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(__pyx_v_kargs == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
    __PYX_ERR(10, 248, __pyx_L1_error)
  }
  if (likely(PyDict_CheckExact(__pyx_v_kargs))) {
    __pyx_t_1 = PyDict_Copy(__pyx_v_kargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 248, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  } else {
    __pyx_t_1 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_v_kargs, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 248, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_v_function, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(10, 248, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_retv = __pyx_t_4;
  __pyx_t_4 = 0;

  /* "SLEPc/slepcnep.pxi":249
 *     (function, args, kargs) = Nep.get_attr('__function__')
 *     retv = function(Nep, toScalar(mu), Amat, Bmat, *args, **kargs)
 *     cdef PetscMat Atmp = NULL, Btmp = NULL             # <<<<<<<<<<<<<<
 *     Atmp = A; A = Amat.mat; Amat.mat = Atmp
 *     Btmp = B; B = Bmat.mat; Bmat.mat = Btmp
 */
  __pyx_v_Atmp = NULL;
  __pyx_v_Btmp = NULL;

  /* "SLEPc/slepcnep.pxi":250
 *     retv = function(Nep, toScalar(mu), Amat, Bmat, *args, **kargs)
 *     cdef PetscMat Atmp = NULL, Btmp = NULL
 *     Atmp = A; A = Amat.mat; Amat.mat = Atmp             # <<<<<<<<<<<<<<
 *     Btmp = B; B = Bmat.mat; Bmat.mat = Btmp
 *     return 0
 */
  __pyx_v_Atmp = __pyx_v_A;
  __pyx_t_7 = __pyx_v_Amat->mat;
  __pyx_v_A = __pyx_t_7;
  __pyx_v_Amat->mat = __pyx_v_Atmp;

  /* "SLEPc/slepcnep.pxi":251
 *     cdef PetscMat Atmp = NULL, Btmp = NULL
 *     Atmp = A; A = Amat.mat; Amat.mat = Atmp
 *     Btmp = B; B = Bmat.mat; Bmat.mat = Btmp             # <<<<<<<<<<<<<<
 *     return 0
 * 
 */
  __pyx_v_Btmp = __pyx_v_B;
  __pyx_t_7 = __pyx_v_Bmat->mat;
  __pyx_v_B = __pyx_t_7;
  __pyx_v_Bmat->mat = __pyx_v_Btmp;

  /* "SLEPc/slepcnep.pxi":252
 *     Atmp = A; A = Amat.mat; Amat.mat = Atmp
 *     Btmp = B; B = Bmat.mat; Bmat.mat = Btmp
 *     return 0             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = 0;
  goto __pyx_L0;

  /* "SLEPc/slepcnep.pxi":237
 * # -----------------------------------------------------------------------------
 * 
 * cdef int NEP_Function(             # <<<<<<<<<<<<<<
 *     SlepcNEP    nep,
 *     PetscScalar mu,
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP_Function", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = PETSC_ERR_PYTHON;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_Nep);
  __Pyx_XDECREF((PyObject *)__pyx_v_Amat);
  __Pyx_XDECREF((PyObject *)__pyx_v_Bmat);
  __Pyx_XDECREF(__pyx_v_function);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XDECREF(__pyx_v_retv);
  __Pyx_RefNannyFinishContext();
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  return __pyx_r;
}

/* "SLEPc/slepcnep.pxi":256
 * # -----------------------------------------------------------------------------
 * 
 * cdef int NEP_Jacobian(             # <<<<<<<<<<<<<<
 *     SlepcNEP    nep,
 *     PetscScalar mu,
 */

static int __pyx_f_8slepc4py_5SLEPc_NEP_Jacobian(NEP __pyx_v_nep, PetscScalar __pyx_v_mu, Mat __pyx_v_J, CYTHON_UNUSED void *__pyx_v_ctx) {
  struct PySlepcNEPObject *__pyx_v_Nep = 0;
  struct PyPetscMatObject *__pyx_v_Jmat = 0;
  PyObject *__pyx_v_jacobian = NULL;
  PyObject *__pyx_v_args = NULL;
  PyObject *__pyx_v_kargs = NULL;
  CYTHON_UNUSED PyObject *__pyx_v_retv = NULL;
  Mat __pyx_v_Jtmp;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *(*__pyx_t_6)(PyObject *);
  Mat __pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  #ifdef WITH_THREAD
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_RefNannySetupContext("NEP_Jacobian", 0);

  /* "SLEPc/slepcnep.pxi":262
 *     void*       ctx,
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef NEP Nep  = ref_NEP(nep)             # <<<<<<<<<<<<<<
 *     cdef Mat Jmat = ref_Mat(J)
 *     (jacobian, args, kargs) = Nep.get_attr('__jacobian__')
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_NEP(__pyx_v_nep)); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 262, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Nep = ((struct PySlepcNEPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepcnep.pxi":263
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef NEP Nep  = ref_NEP(nep)
 *     cdef Mat Jmat = ref_Mat(J)             # <<<<<<<<<<<<<<
 *     (jacobian, args, kargs) = Nep.get_attr('__jacobian__')
 *     retv = jacobian(Nep, toScalar(mu), Jmat, *args, **kargs)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_Mat(__pyx_v_J)); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 263, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Jmat = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepcnep.pxi":264
 *     cdef NEP Nep  = ref_NEP(nep)
 *     cdef Mat Jmat = ref_Mat(J)
 *     (jacobian, args, kargs) = Nep.get_attr('__jacobian__')             # <<<<<<<<<<<<<<
 *     retv = jacobian(Nep, toScalar(mu), Jmat, *args, **kargs)
 *     cdef PetscMat Jtmp = NULL
 */
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_Nep->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_Nep), ((char *)"__jacobian__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 264, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
    PyObject* sequence = __pyx_t_1;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 3)) {
      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(10, 264, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); 
    } else {
      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyList_GET_ITEM(sequence, 2); 
    }
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_4);
    #else
    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 264, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(10, 264, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(10, 264, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    #endif
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(10, 264, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
    index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_2);
    index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_3);
    index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(10, 264, __pyx_L1_error)
    __pyx_t_6 = NULL;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L4_unpacking_done;
    __pyx_L3_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(10, 264, __pyx_L1_error)
    __pyx_L4_unpacking_done:;
  }
  __pyx_v_jacobian = __pyx_t_2;
  __pyx_t_2 = 0;
  __pyx_v_args = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_kargs = __pyx_t_4;
  __pyx_t_4 = 0;

  /* "SLEPc/slepcnep.pxi":265
 *     cdef Mat Jmat = ref_Mat(J)
 *     (jacobian, args, kargs) = Nep.get_attr('__jacobian__')
 *     retv = jacobian(Nep, toScalar(mu), Jmat, *args, **kargs)             # <<<<<<<<<<<<<<
 *     cdef PetscMat Jtmp = NULL
 *     Jtmp = J; J = Jmat.mat; Jmat.mat = Jtmp
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_mu); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 265, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(10, 265, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(((PyObject *)__pyx_v_Nep));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_Nep));
  PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_Nep));
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
  __Pyx_INCREF(((PyObject *)__pyx_v_Jmat));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_Jmat));
  PyTuple_SET_ITEM(__pyx_t_4, 2, ((PyObject *)__pyx_v_Jmat));
  __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 265, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyNumber_Add(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(10, 265, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(__pyx_v_kargs == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
    __PYX_ERR(10, 265, __pyx_L1_error)
  }
  if (likely(PyDict_CheckExact(__pyx_v_kargs))) {
    __pyx_t_1 = PyDict_Copy(__pyx_v_kargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 265, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  } else {
    __pyx_t_1 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_v_kargs, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 265, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_v_jacobian, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(10, 265, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_retv = __pyx_t_4;
  __pyx_t_4 = 0;

  /* "SLEPc/slepcnep.pxi":266
 *     (jacobian, args, kargs) = Nep.get_attr('__jacobian__')
 *     retv = jacobian(Nep, toScalar(mu), Jmat, *args, **kargs)
 *     cdef PetscMat Jtmp = NULL             # <<<<<<<<<<<<<<
 *     Jtmp = J; J = Jmat.mat; Jmat.mat = Jtmp
 *     return 0
 */
  __pyx_v_Jtmp = NULL;

  /* "SLEPc/slepcnep.pxi":267
 *     retv = jacobian(Nep, toScalar(mu), Jmat, *args, **kargs)
 *     cdef PetscMat Jtmp = NULL
 *     Jtmp = J; J = Jmat.mat; Jmat.mat = Jtmp             # <<<<<<<<<<<<<<
 *     return 0
 * 
 */
  __pyx_v_Jtmp = __pyx_v_J;
  __pyx_t_7 = __pyx_v_Jmat->mat;
  __pyx_v_J = __pyx_t_7;
  __pyx_v_Jmat->mat = __pyx_v_Jtmp;

  /* "SLEPc/slepcnep.pxi":268
 *     cdef PetscMat Jtmp = NULL
 *     Jtmp = J; J = Jmat.mat; Jmat.mat = Jtmp
 *     return 0             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = 0;
  goto __pyx_L0;

  /* "SLEPc/slepcnep.pxi":256
 * # -----------------------------------------------------------------------------
 * 
 * cdef int NEP_Jacobian(             # <<<<<<<<<<<<<<
 *     SlepcNEP    nep,
 *     PetscScalar mu,
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP_Jacobian", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = PETSC_ERR_PYTHON;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_Nep);
  __Pyx_XDECREF((PyObject *)__pyx_v_Jmat);
  __Pyx_XDECREF(__pyx_v_jacobian);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XDECREF(__pyx_v_retv);
  __Pyx_RefNannyFinishContext();
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  return __pyx_r;
}

/* "SLEPc/slepcnep.pxi":272
 * # -----------------------------------------------------------------------------
 * 
 * cdef int NEP_Stopping(             # <<<<<<<<<<<<<<
 *     SlepcNEP                nep,
 *     PetscInt                its,
 */

static int __pyx_f_8slepc4py_5SLEPc_NEP_Stopping(NEP __pyx_v_nep, PetscInt __pyx_v_its, PetscInt __pyx_v_max_it, PetscInt __pyx_v_nconv, PetscInt __pyx_v_nev, NEPConvergedReason *__pyx_v_r, CYTHON_UNUSED void *__pyx_v_ctx) {
  struct PySlepcNEPObject *__pyx_v_Nep = 0;
  PyObject *__pyx_v_stopping = NULL;
  PyObject *__pyx_v_args = NULL;
  PyObject *__pyx_v_kargs = NULL;
  PyObject *__pyx_v_reason = NULL;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *(*__pyx_t_6)(PyObject *);
  int __pyx_t_7;
  int __pyx_t_8;
  NEPConvergedReason __pyx_t_9;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  #ifdef WITH_THREAD
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_RefNannySetupContext("NEP_Stopping", 0);

  /* "SLEPc/slepcnep.pxi":281
 *     void                    *ctx,
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef NEP Nep = ref_NEP(nep)             # <<<<<<<<<<<<<<
 *     (stopping, args, kargs) = Nep.get_attr('__stopping__')
 *     reason = stopping(Nep, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_NEP(__pyx_v_nep)); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 281, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Nep = ((struct PySlepcNEPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepcnep.pxi":282
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef NEP Nep = ref_NEP(nep)
 *     (stopping, args, kargs) = Nep.get_attr('__stopping__')             # <<<<<<<<<<<<<<
 *     reason = stopping(Nep, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 *     if   reason is None:  r[0] = NEP_CONVERGED_ITERATING
 */
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_Nep->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_Nep), ((char *)"__stopping__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 282, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
    PyObject* sequence = __pyx_t_1;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 3)) {
      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(10, 282, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); 
    } else {
      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyList_GET_ITEM(sequence, 2); 
    }
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_4);
    #else
    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 282, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(10, 282, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(10, 282, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    #endif
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(10, 282, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
    index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_2);
    index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_3);
    index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(10, 282, __pyx_L1_error)
    __pyx_t_6 = NULL;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L4_unpacking_done;
    __pyx_L3_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(10, 282, __pyx_L1_error)
    __pyx_L4_unpacking_done:;
  }
  __pyx_v_stopping = __pyx_t_2;
  __pyx_t_2 = 0;
  __pyx_v_args = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_kargs = __pyx_t_4;
  __pyx_t_4 = 0;

  /* "SLEPc/slepcnep.pxi":283
 *     cdef NEP Nep = ref_NEP(nep)
 *     (stopping, args, kargs) = Nep.get_attr('__stopping__')
 *     reason = stopping(Nep, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)             # <<<<<<<<<<<<<<
 *     if   reason is None:  r[0] = NEP_CONVERGED_ITERATING
 *     elif reason is False: r[0] = NEP_CONVERGED_ITERATING
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_its); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 283, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_max_it); if (unlikely(!__pyx_t_4)) __PYX_ERR(10, 283, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_nconv); if (unlikely(!__pyx_t_3)) __PYX_ERR(10, 283, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_nev); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 283, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(10, 283, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_INCREF(((PyObject *)__pyx_v_Nep));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_Nep));
  PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_Nep));
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_t_2);
  __pyx_t_1 = 0;
  __pyx_t_4 = 0;
  __pyx_t_3 = 0;
  __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 283, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = PyNumber_Add(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(10, 283, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(__pyx_v_kargs == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
    __PYX_ERR(10, 283, __pyx_L1_error)
  }
  if (likely(PyDict_CheckExact(__pyx_v_kargs))) {
    __pyx_t_2 = PyDict_Copy(__pyx_v_kargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 283, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  } else {
    __pyx_t_2 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_v_kargs, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 283, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
  }
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_v_stopping, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(10, 283, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_reason = __pyx_t_5;
  __pyx_t_5 = 0;

  /* "SLEPc/slepcnep.pxi":284
 *     (stopping, args, kargs) = Nep.get_attr('__stopping__')
 *     reason = stopping(Nep, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 *     if   reason is None:  r[0] = NEP_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *     elif reason is False: r[0] = NEP_CONVERGED_ITERATING
 *     elif reason is True:  r[0] = NEP_CONVERGED_USER
 */
  __pyx_t_7 = (__pyx_v_reason == Py_None);
  __pyx_t_8 = (__pyx_t_7 != 0);
  if (__pyx_t_8) {
    (__pyx_v_r[0]) = NEP_CONVERGED_ITERATING;
    goto __pyx_L5;
  }

  /* "SLEPc/slepcnep.pxi":285
 *     reason = stopping(Nep, toInt(its), toInt(max_it), toInt(nconv), toInt(nev), *args, **kargs)
 *     if   reason is None:  r[0] = NEP_CONVERGED_ITERATING
 *     elif reason is False: r[0] = NEP_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *     elif reason is True:  r[0] = NEP_CONVERGED_USER
 *     else:                 r[0] = reason
 */
  __pyx_t_8 = (__pyx_v_reason == Py_False);
  __pyx_t_7 = (__pyx_t_8 != 0);
  if (__pyx_t_7) {
    (__pyx_v_r[0]) = NEP_CONVERGED_ITERATING;
    goto __pyx_L5;
  }

  /* "SLEPc/slepcnep.pxi":286
 *     if   reason is None:  r[0] = NEP_CONVERGED_ITERATING
 *     elif reason is False: r[0] = NEP_CONVERGED_ITERATING
 *     elif reason is True:  r[0] = NEP_CONVERGED_USER             # <<<<<<<<<<<<<<
 *     else:                 r[0] = reason
 * 
 */
  __pyx_t_7 = (__pyx_v_reason == Py_True);
  __pyx_t_8 = (__pyx_t_7 != 0);
  if (__pyx_t_8) {
    (__pyx_v_r[0]) = NEP_CONVERGED_USER;
    goto __pyx_L5;
  }

  /* "SLEPc/slepcnep.pxi":287
 *     elif reason is False: r[0] = NEP_CONVERGED_ITERATING
 *     elif reason is True:  r[0] = NEP_CONVERGED_USER
 *     else:                 r[0] = reason             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  /*else*/ {
    __pyx_t_9 = ((NEPConvergedReason)__Pyx_PyInt_As_NEPConvergedReason(__pyx_v_reason)); if (unlikely(PyErr_Occurred())) __PYX_ERR(10, 287, __pyx_L1_error)
    (__pyx_v_r[0]) = __pyx_t_9;
  }
  __pyx_L5:;

  /* "SLEPc/slepcnep.pxi":272
 * # -----------------------------------------------------------------------------
 * 
 * cdef int NEP_Stopping(             # <<<<<<<<<<<<<<
 *     SlepcNEP                nep,
 *     PetscInt                its,
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP_Stopping", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = PETSC_ERR_PYTHON;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_Nep);
  __Pyx_XDECREF(__pyx_v_stopping);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XDECREF(__pyx_v_reason);
  __Pyx_RefNannyFinishContext();
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  return __pyx_r;
}

/* "SLEPc/slepcnep.pxi":291
 * # -----------------------------------------------------------------------------
 * 
 * cdef int NEP_Monitor(             # <<<<<<<<<<<<<<
 *     SlepcNEP    nep,
 *     PetscInt    its,
 */

static int __pyx_f_8slepc4py_5SLEPc_NEP_Monitor(NEP __pyx_v_nep, PetscInt __pyx_v_its, PetscInt __pyx_v_nconv, PetscScalar *__pyx_v_eigr, PetscScalar *__pyx_v_eigi, PetscReal *__pyx_v_errest, PetscInt __pyx_v_nest, CYTHON_UNUSED void *__pyx_v_ctx) {
  struct PySlepcNEPObject *__pyx_v_Nep = 0;
  PyObject *__pyx_v_monitorlist = 0;
  PyObject *__pyx_v_eig = 0;
  PyObject *__pyx_v_err = 0;
  PyObject *__pyx_v_monitor = NULL;
  PyObject *__pyx_v_args = NULL;
  PyObject *__pyx_v_kargs = NULL;
  PetscInt __pyx_8genexpr6__pyx_v_i;
  PetscInt __pyx_8genexpr7__pyx_v_i;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_t_3;
  PetscInt __pyx_t_4;
  PetscInt __pyx_t_5;
  PetscInt __pyx_t_6;
  PyObject *__pyx_t_7 = NULL;
  Py_ssize_t __pyx_t_8;
  PyObject *(*__pyx_t_9)(PyObject *);
  PyObject *__pyx_t_10 = NULL;
  PyObject *__pyx_t_11 = NULL;
  PyObject *__pyx_t_12 = NULL;
  PyObject *__pyx_t_13 = NULL;
  PyObject *(*__pyx_t_14)(PyObject *);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  #ifdef WITH_THREAD
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_RefNannySetupContext("NEP_Monitor", 0);

  /* "SLEPc/slepcnep.pxi":301
 *     void        *ctx,
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef NEP Nep = ref_NEP(nep)             # <<<<<<<<<<<<<<
 *     cdef object monitorlist = Nep.get_attr('__monitor__')
 *     if monitorlist is None: return 0
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_NEP(__pyx_v_nep)); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 301, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Nep = ((struct PySlepcNEPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepcnep.pxi":302
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef NEP Nep = ref_NEP(nep)
 *     cdef object monitorlist = Nep.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 *     if monitorlist is None: return 0
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 */
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_Nep->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_Nep), ((char *)"__monitor__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 302, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_monitorlist = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/slepcnep.pxi":303
 *     cdef NEP Nep = ref_NEP(nep)
 *     cdef object monitorlist = Nep.get_attr('__monitor__')
 *     if monitorlist is None: return 0             # <<<<<<<<<<<<<<
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 */
  __pyx_t_2 = (__pyx_v_monitorlist == Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_r = 0;
    goto __pyx_L0;
  }

  /* "SLEPc/slepcnep.pxi":304
 *     cdef object monitorlist = Nep.get_attr('__monitor__')
 *     if monitorlist is None: return 0
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]             # <<<<<<<<<<<<<<
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:
 */
  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 304, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __pyx_v_nest;
    __pyx_t_5 = __pyx_t_4;
    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
      __pyx_8genexpr6__pyx_v_i = __pyx_t_6;
      __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toComplex((__pyx_v_eigr[__pyx_8genexpr6__pyx_v_i]), (__pyx_v_eigi[__pyx_8genexpr6__pyx_v_i])); if (unlikely(!__pyx_t_7)) __PYX_ERR(10, 304, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(10, 304, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    }
  } /* exit inner scope */
  __pyx_v_eig = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/slepcnep.pxi":305
 *     if monitorlist is None: return 0
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]             # <<<<<<<<<<<<<<
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Nep, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 */
  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 305, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __pyx_v_nest;
    __pyx_t_5 = __pyx_t_4;
    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
      __pyx_8genexpr7__pyx_v_i = __pyx_t_6;
      __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toReal((__pyx_v_errest[__pyx_8genexpr7__pyx_v_i])); if (unlikely(!__pyx_t_7)) __PYX_ERR(10, 305, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(10, 305, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    }
  } /* exit inner scope */
  __pyx_v_err = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/slepcnep.pxi":306
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:             # <<<<<<<<<<<<<<
 *         monitor(Nep, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 *     return 0
 */
  if (likely(PyList_CheckExact(__pyx_v_monitorlist)) || PyTuple_CheckExact(__pyx_v_monitorlist)) {
    __pyx_t_1 = __pyx_v_monitorlist; __Pyx_INCREF(__pyx_t_1); __pyx_t_8 = 0;
    __pyx_t_9 = NULL;
  } else {
    __pyx_t_8 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_monitorlist); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 306, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_9 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(10, 306, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_9)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_7 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(10, 306, __pyx_L1_error)
        #else
        __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(10, 306, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        #endif
      } else {
        if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(10, 306, __pyx_L1_error)
        #else
        __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(10, 306, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        #endif
      }
    } else {
      __pyx_t_7 = __pyx_t_9(__pyx_t_1);
      if (unlikely(!__pyx_t_7)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(10, 306, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_7);
    }
    if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) {
      PyObject* sequence = __pyx_t_7;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 3)) {
        if (size > 3) __Pyx_RaiseTooManyValuesError(3);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(10, 306, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_10 = PyTuple_GET_ITEM(sequence, 0); 
        __pyx_t_11 = PyTuple_GET_ITEM(sequence, 1); 
        __pyx_t_12 = PyTuple_GET_ITEM(sequence, 2); 
      } else {
        __pyx_t_10 = PyList_GET_ITEM(sequence, 0); 
        __pyx_t_11 = PyList_GET_ITEM(sequence, 1); 
        __pyx_t_12 = PyList_GET_ITEM(sequence, 2); 
      }
      __Pyx_INCREF(__pyx_t_10);
      __Pyx_INCREF(__pyx_t_11);
      __Pyx_INCREF(__pyx_t_12);
      #else
      __pyx_t_10 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(10, 306, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_11 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(10, 306, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_12 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_12)) __PYX_ERR(10, 306, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      #endif
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_13 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_13)) __PYX_ERR(10, 306, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_14 = Py_TYPE(__pyx_t_13)->tp_iternext;
      index = 0; __pyx_t_10 = __pyx_t_14(__pyx_t_13); if (unlikely(!__pyx_t_10)) goto __pyx_L10_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_10);
      index = 1; __pyx_t_11 = __pyx_t_14(__pyx_t_13); if (unlikely(!__pyx_t_11)) goto __pyx_L10_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_11);
      index = 2; __pyx_t_12 = __pyx_t_14(__pyx_t_13); if (unlikely(!__pyx_t_12)) goto __pyx_L10_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_12);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_13), 3) < 0) __PYX_ERR(10, 306, __pyx_L1_error)
      __pyx_t_14 = NULL;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      goto __pyx_L11_unpacking_done;
      __pyx_L10_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __pyx_t_14 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(10, 306, __pyx_L1_error)
      __pyx_L11_unpacking_done:;
    }
    __Pyx_XDECREF_SET(__pyx_v_monitor, __pyx_t_10);
    __pyx_t_10 = 0;
    __Pyx_XDECREF_SET(__pyx_v_args, __pyx_t_11);
    __pyx_t_11 = 0;
    __Pyx_XDECREF_SET(__pyx_v_kargs, __pyx_t_12);
    __pyx_t_12 = 0;

    /* "SLEPc/slepcnep.pxi":307
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Nep, toInt(its), toInt(nconv), eig, err, *args, **kargs)             # <<<<<<<<<<<<<<
 *     return 0
 * 
 */
    __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_its); if (unlikely(!__pyx_t_7)) __PYX_ERR(10, 307, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_12 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_nconv); if (unlikely(!__pyx_t_12)) __PYX_ERR(10, 307, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_11 = PyTuple_New(5); if (unlikely(!__pyx_t_11)) __PYX_ERR(10, 307, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_INCREF(((PyObject *)__pyx_v_Nep));
    __Pyx_GIVEREF(((PyObject *)__pyx_v_Nep));
    PyTuple_SET_ITEM(__pyx_t_11, 0, ((PyObject *)__pyx_v_Nep));
    __Pyx_GIVEREF(__pyx_t_7);
    PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_7);
    __Pyx_GIVEREF(__pyx_t_12);
    PyTuple_SET_ITEM(__pyx_t_11, 2, __pyx_t_12);
    __Pyx_INCREF(__pyx_v_eig);
    __Pyx_GIVEREF(__pyx_v_eig);
    PyTuple_SET_ITEM(__pyx_t_11, 3, __pyx_v_eig);
    __Pyx_INCREF(__pyx_v_err);
    __Pyx_GIVEREF(__pyx_v_err);
    PyTuple_SET_ITEM(__pyx_t_11, 4, __pyx_v_err);
    __pyx_t_7 = 0;
    __pyx_t_12 = 0;
    __pyx_t_12 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_12)) __PYX_ERR(10, 307, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_7 = PyNumber_Add(__pyx_t_11, __pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(10, 307, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    if (unlikely(__pyx_v_kargs == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
      __PYX_ERR(10, 307, __pyx_L1_error)
    }
    if (likely(PyDict_CheckExact(__pyx_v_kargs))) {
      __pyx_t_12 = PyDict_Copy(__pyx_v_kargs); if (unlikely(!__pyx_t_12)) __PYX_ERR(10, 307, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
    } else {
      __pyx_t_12 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_v_kargs, NULL); if (unlikely(!__pyx_t_12)) __PYX_ERR(10, 307, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
    }
    __pyx_t_11 = __Pyx_PyObject_Call(__pyx_v_monitor, __pyx_t_7, __pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(10, 307, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;

    /* "SLEPc/slepcnep.pxi":306
 *     cdef object eig = [toComplex(eigr[i], eigi[i]) for i in range(nest)]
 *     cdef object err = [toReal(errest[i]) for i in range(nest)]
 *     for (monitor, args, kargs) in monitorlist:             # <<<<<<<<<<<<<<
 *         monitor(Nep, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 *     return 0
 */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/slepcnep.pxi":308
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Nep, toInt(its), toInt(nconv), eig, err, *args, **kargs)
 *     return 0             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = 0;
  goto __pyx_L0;

  /* "SLEPc/slepcnep.pxi":291
 * # -----------------------------------------------------------------------------
 * 
 * cdef int NEP_Monitor(             # <<<<<<<<<<<<<<
 *     SlepcNEP    nep,
 *     PetscInt    its,
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP_Monitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = PETSC_ERR_PYTHON;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_Nep);
  __Pyx_XDECREF(__pyx_v_monitorlist);
  __Pyx_XDECREF(__pyx_v_eig);
  __Pyx_XDECREF(__pyx_v_err);
  __Pyx_XDECREF(__pyx_v_monitor);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_RefNannyFinishContext();
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  return __pyx_r;
}

/* "SLEPc/slepcmfn.pxi":57
 * # -----------------------------------------------------------------------------
 * 
 * cdef inline MFN ref_MFN(SlepcMFN mfn):             # <<<<<<<<<<<<<<
 *     cdef MFN ob = <MFN> MFN()
 *     ob.mfn = mfn
 */

static CYTHON_INLINE struct PySlepcMFNObject *__pyx_f_8slepc4py_5SLEPc_ref_MFN(MFN __pyx_v_mfn) {
  struct PySlepcMFNObject *__pyx_v_ob = 0;
  struct PySlepcMFNObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("ref_MFN", 0);

  /* "SLEPc/slepcmfn.pxi":58
 * 
 * cdef inline MFN ref_MFN(SlepcMFN mfn):
 *     cdef MFN ob = <MFN> MFN()             # <<<<<<<<<<<<<<
 *     ob.mfn = mfn
 *     PetscINCREF(ob.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_MFN)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 58, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_t_1;
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_ob = ((struct PySlepcMFNObject *)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/slepcmfn.pxi":59
 * cdef inline MFN ref_MFN(SlepcMFN mfn):
 *     cdef MFN ob = <MFN> MFN()
 *     ob.mfn = mfn             # <<<<<<<<<<<<<<
 *     PetscINCREF(ob.obj)
 *     return ob
 */
  __pyx_v_ob->mfn = __pyx_v_mfn;

  /* "SLEPc/slepcmfn.pxi":60
 *     cdef MFN ob = <MFN> MFN()
 *     ob.mfn = mfn
 *     PetscINCREF(ob.obj)             # <<<<<<<<<<<<<<
 *     return ob
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ob->__pyx_base.obj));

  /* "SLEPc/slepcmfn.pxi":61
 *     ob.mfn = mfn
 *     PetscINCREF(ob.obj)
 *     return ob             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __Pyx_XDECREF(((PyObject *)__pyx_r));
  __Pyx_INCREF(((PyObject *)__pyx_v_ob));
  __pyx_r = __pyx_v_ob;
  goto __pyx_L0;

  /* "SLEPc/slepcmfn.pxi":57
 * # -----------------------------------------------------------------------------
 * 
 * cdef inline MFN ref_MFN(SlepcMFN mfn):             # <<<<<<<<<<<<<<
 *     cdef MFN ob = <MFN> MFN()
 *     ob.mfn = mfn
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ref_MFN", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_XGIVEREF((PyObject *)__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/slepcmfn.pxi":65
 * # -----------------------------------------------------------------------------
 * 
 * cdef int MFN_Monitor(             # <<<<<<<<<<<<<<
 *     SlepcMFN    mfn,
 *     PetscInt    it,
 */

static int __pyx_f_8slepc4py_5SLEPc_MFN_Monitor(MFN __pyx_v_mfn, PetscInt __pyx_v_it, PetscReal __pyx_v_errest, CYTHON_UNUSED void *__pyx_v_ctx) {
  struct PySlepcMFNObject *__pyx_v_Mfn = 0;
  PyObject *__pyx_v_monitorlist = 0;
  PyObject *__pyx_v_monitor = NULL;
  PyObject *__pyx_v_args = NULL;
  PyObject *__pyx_v_kargs = NULL;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_t_3;
  Py_ssize_t __pyx_t_4;
  PyObject *(*__pyx_t_5)(PyObject *);
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  PyObject *__pyx_t_10 = NULL;
  PyObject *(*__pyx_t_11)(PyObject *);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  #ifdef WITH_THREAD
  PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure();
  #endif
  __Pyx_RefNannySetupContext("MFN_Monitor", 0);

  /* "SLEPc/slepcmfn.pxi":71
 *     void        *ctx,
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef MFN Mfn = ref_MFN(mfn)             # <<<<<<<<<<<<<<
 *     cdef object monitorlist = Mfn.get_attr('__monitor__')
 *     if monitorlist is None: return 0
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_MFN(__pyx_v_mfn)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 71, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_Mfn = ((struct PySlepcMFNObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/slepcmfn.pxi":72
 *     ) except PETSC_ERR_PYTHON with gil:
 *     cdef MFN Mfn = ref_MFN(mfn)
 *     cdef object monitorlist = Mfn.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 *     if monitorlist is None: return 0
 *     for (monitor, args, kargs) in monitorlist:
 */
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_MFN *)__pyx_v_Mfn->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_Mfn), ((char *)"__monitor__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 72, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_monitorlist = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/slepcmfn.pxi":73
 *     cdef MFN Mfn = ref_MFN(mfn)
 *     cdef object monitorlist = Mfn.get_attr('__monitor__')
 *     if monitorlist is None: return 0             # <<<<<<<<<<<<<<
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Mfn, toInt(it), toReal(errest), *args, **kargs)
 */
  __pyx_t_2 = (__pyx_v_monitorlist == Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_r = 0;
    goto __pyx_L0;
  }

  /* "SLEPc/slepcmfn.pxi":74
 *     cdef object monitorlist = Mfn.get_attr('__monitor__')
 *     if monitorlist is None: return 0
 *     for (monitor, args, kargs) in monitorlist:             # <<<<<<<<<<<<<<
 *         monitor(Mfn, toInt(it), toReal(errest), *args, **kargs)
 *     return 0
 */
  if (likely(PyList_CheckExact(__pyx_v_monitorlist)) || PyTuple_CheckExact(__pyx_v_monitorlist)) {
    __pyx_t_1 = __pyx_v_monitorlist; __Pyx_INCREF(__pyx_t_1); __pyx_t_4 = 0;
    __pyx_t_5 = NULL;
  } else {
    __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_monitorlist); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 74, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(11, 74, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_5)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_6 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(11, 74, __pyx_L1_error)
        #else
        __pyx_t_6 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(11, 74, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        #endif
      } else {
        if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(11, 74, __pyx_L1_error)
        #else
        __pyx_t_6 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(11, 74, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        #endif
      }
    } else {
      __pyx_t_6 = __pyx_t_5(__pyx_t_1);
      if (unlikely(!__pyx_t_6)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(11, 74, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_6);
    }
    if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) {
      PyObject* sequence = __pyx_t_6;
      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
      if (unlikely(size != 3)) {
        if (size > 3) __Pyx_RaiseTooManyValuesError(3);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(11, 74, __pyx_L1_error)
      }
      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); 
        __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); 
        __pyx_t_9 = PyTuple_GET_ITEM(sequence, 2); 
      } else {
        __pyx_t_7 = PyList_GET_ITEM(sequence, 0); 
        __pyx_t_8 = PyList_GET_ITEM(sequence, 1); 
        __pyx_t_9 = PyList_GET_ITEM(sequence, 2); 
      }
      __Pyx_INCREF(__pyx_t_7);
      __Pyx_INCREF(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_9);
      #else
      __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(11, 74, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(11, 74, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_9 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_9)) __PYX_ERR(11, 74, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      #endif
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_10 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(11, 74, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __pyx_t_11 = Py_TYPE(__pyx_t_10)->tp_iternext;
      index = 0; __pyx_t_7 = __pyx_t_11(__pyx_t_10); if (unlikely(!__pyx_t_7)) goto __pyx_L6_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_7);
      index = 1; __pyx_t_8 = __pyx_t_11(__pyx_t_10); if (unlikely(!__pyx_t_8)) goto __pyx_L6_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_8);
      index = 2; __pyx_t_9 = __pyx_t_11(__pyx_t_10); if (unlikely(!__pyx_t_9)) goto __pyx_L6_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_9);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_10), 3) < 0) __PYX_ERR(11, 74, __pyx_L1_error)
      __pyx_t_11 = NULL;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      goto __pyx_L7_unpacking_done;
      __pyx_L6_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_11 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(11, 74, __pyx_L1_error)
      __pyx_L7_unpacking_done:;
    }
    __Pyx_XDECREF_SET(__pyx_v_monitor, __pyx_t_7);
    __pyx_t_7 = 0;
    __Pyx_XDECREF_SET(__pyx_v_args, __pyx_t_8);
    __pyx_t_8 = 0;
    __Pyx_XDECREF_SET(__pyx_v_kargs, __pyx_t_9);
    __pyx_t_9 = 0;

    /* "SLEPc/slepcmfn.pxi":75
 *     if monitorlist is None: return 0
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Mfn, toInt(it), toReal(errest), *args, **kargs)             # <<<<<<<<<<<<<<
 *     return 0
 * 
 */
    __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_it); if (unlikely(!__pyx_t_6)) __PYX_ERR(11, 75, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_9 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_errest); if (unlikely(!__pyx_t_9)) __PYX_ERR(11, 75, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(11, 75, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_INCREF(((PyObject *)__pyx_v_Mfn));
    __Pyx_GIVEREF(((PyObject *)__pyx_v_Mfn));
    PyTuple_SET_ITEM(__pyx_t_8, 0, ((PyObject *)__pyx_v_Mfn));
    __Pyx_GIVEREF(__pyx_t_6);
    PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6);
    __Pyx_GIVEREF(__pyx_t_9);
    PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_9);
    __pyx_t_6 = 0;
    __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_9)) __PYX_ERR(11, 75, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_6 = PyNumber_Add(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(11, 75, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(__pyx_v_kargs == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType");
      __PYX_ERR(11, 75, __pyx_L1_error)
    }
    if (likely(PyDict_CheckExact(__pyx_v_kargs))) {
      __pyx_t_9 = PyDict_Copy(__pyx_v_kargs); if (unlikely(!__pyx_t_9)) __PYX_ERR(11, 75, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
    } else {
      __pyx_t_9 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_v_kargs, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(11, 75, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
    }
    __pyx_t_8 = __Pyx_PyObject_Call(__pyx_v_monitor, __pyx_t_6, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(11, 75, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

    /* "SLEPc/slepcmfn.pxi":74
 *     cdef object monitorlist = Mfn.get_attr('__monitor__')
 *     if monitorlist is None: return 0
 *     for (monitor, args, kargs) in monitorlist:             # <<<<<<<<<<<<<<
 *         monitor(Mfn, toInt(it), toReal(errest), *args, **kargs)
 *     return 0
 */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/slepcmfn.pxi":76
 *     for (monitor, args, kargs) in monitorlist:
 *         monitor(Mfn, toInt(it), toReal(errest), *args, **kargs)
 *     return 0             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = 0;
  goto __pyx_L0;

  /* "SLEPc/slepcmfn.pxi":65
 * # -----------------------------------------------------------------------------
 * 
 * cdef int MFN_Monitor(             # <<<<<<<<<<<<<<
 *     SlepcMFN    mfn,
 *     PetscInt    it,
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN_Monitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = PETSC_ERR_PYTHON;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_Mfn);
  __Pyx_XDECREF(__pyx_v_monitorlist);
  __Pyx_XDECREF(__pyx_v_monitor);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_RefNannyFinishContext();
  #ifdef WITH_THREAD
  __Pyx_PyGILState_Release(__pyx_gilstate_save);
  #endif
  return __pyx_r;
}

/* "SLEPc/Sys.pyx":6
 * 
 *     @classmethod
 *     def getVersion(cls, devel=False, date=False, author=False):             # <<<<<<<<<<<<<<
 *         cdef char cversion[256]
 *         cdef PetscInt major=0, minor=0, micro=0, release=0
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3Sys_1getVersion(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3Sys_getVersion[] = "Sys.getVersion(type cls, devel=False, date=False, author=False)";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3Sys_1getVersion(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_devel = 0;
  PyObject *__pyx_v_date = 0;
  PyObject *__pyx_v_author = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getVersion (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_devel,&__pyx_n_s_date,&__pyx_n_s_author,0};
    PyObject* values[3] = {0,0,0};
    values[0] = ((PyObject *)Py_False);
    values[1] = ((PyObject *)Py_False);
    values[2] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_devel);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_date);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_author);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getVersion") < 0)) __PYX_ERR(12, 6, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_devel = values[0];
    __pyx_v_date = values[1];
    __pyx_v_author = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getVersion", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 6, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.Sys.getVersion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3Sys_getVersion(((PyTypeObject*)__pyx_v_cls), __pyx_v_devel, __pyx_v_date, __pyx_v_author);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3Sys_getVersion(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_devel, PyObject *__pyx_v_date, PyObject *__pyx_v_author) {
  char __pyx_v_cversion[0x100];
  PetscInt __pyx_v_major;
  PetscInt __pyx_v_minor;
  PetscInt __pyx_v_micro;
  PetscInt __pyx_v_release;
  PyObject *__pyx_v_out = NULL;
  PyObject *__pyx_v_version = NULL;
  PyObject *__pyx_v_vstr = NULL;
  PyObject *__pyx_8genexpr8__pyx_v_s = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_t_6;
  int __pyx_t_7;
  int __pyx_t_8;
  Py_ssize_t __pyx_t_9;
  PyObject *(*__pyx_t_10)(PyObject *);
  PyObject *__pyx_t_11 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getVersion", 0);
  __Pyx_INCREF(__pyx_v_date);
  __Pyx_INCREF(__pyx_v_author);

  /* "SLEPc/Sys.pyx":8
 *     def getVersion(cls, devel=False, date=False, author=False):
 *         cdef char cversion[256]
 *         cdef PetscInt major=0, minor=0, micro=0, release=0             # <<<<<<<<<<<<<<
 *         CHKERR( SlepcGetVersion(cversion, sizeof(cversion)) )
 *         CHKERR( SlepcGetVersionNumber(&major, &minor, &micro, &release) )
 */
  __pyx_v_major = 0;
  __pyx_v_minor = 0;
  __pyx_v_micro = 0;
  __pyx_v_release = 0;

  /* "SLEPc/Sys.pyx":9
 *         cdef char cversion[256]
 *         cdef PetscInt major=0, minor=0, micro=0, release=0
 *         CHKERR( SlepcGetVersion(cversion, sizeof(cversion)) )             # <<<<<<<<<<<<<<
 *         CHKERR( SlepcGetVersionNumber(&major, &minor, &micro, &release) )
 *         out = version = (toInt(major), toInt(minor), toInt(micro))
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SlepcGetVersion(__pyx_v_cversion, (sizeof(__pyx_v_cversion)))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(12, 9, __pyx_L1_error)

  /* "SLEPc/Sys.pyx":10
 *         cdef PetscInt major=0, minor=0, micro=0, release=0
 *         CHKERR( SlepcGetVersion(cversion, sizeof(cversion)) )
 *         CHKERR( SlepcGetVersionNumber(&major, &minor, &micro, &release) )             # <<<<<<<<<<<<<<
 *         out = version = (toInt(major), toInt(minor), toInt(micro))
 *         if devel or date or author:
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SlepcGetVersionNumber((&__pyx_v_major), (&__pyx_v_minor), (&__pyx_v_micro), (&__pyx_v_release))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(12, 10, __pyx_L1_error)

  /* "SLEPc/Sys.pyx":11
 *         CHKERR( SlepcGetVersion(cversion, sizeof(cversion)) )
 *         CHKERR( SlepcGetVersionNumber(&major, &minor, &micro, &release) )
 *         out = version = (toInt(major), toInt(minor), toInt(micro))             # <<<<<<<<<<<<<<
 *         if devel or date or author:
 *             out = [version]
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_major); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 11, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_minor); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 11, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_micro); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 11, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 11, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __Pyx_INCREF(__pyx_t_5);
  __pyx_v_out = __pyx_t_5;
  __Pyx_INCREF(__pyx_t_5);
  __pyx_v_version = __pyx_t_5;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

  /* "SLEPc/Sys.pyx":12
 *         CHKERR( SlepcGetVersionNumber(&major, &minor, &micro, &release) )
 *         out = version = (toInt(major), toInt(minor), toInt(micro))
 *         if devel or date or author:             # <<<<<<<<<<<<<<
 *             out = [version]
 *             if devel:
 */
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_devel); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(12, 12, __pyx_L1_error)
  if (!__pyx_t_7) {
  } else {
    __pyx_t_6 = __pyx_t_7;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_date); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(12, 12, __pyx_L1_error)
  if (!__pyx_t_7) {
  } else {
    __pyx_t_6 = __pyx_t_7;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_author); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(12, 12, __pyx_L1_error)
  __pyx_t_6 = __pyx_t_7;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_6) {

    /* "SLEPc/Sys.pyx":13
 *         out = version = (toInt(major), toInt(minor), toInt(micro))
 *         if devel or date or author:
 *             out = [version]             # <<<<<<<<<<<<<<
 *             if devel:
 *                 out.append(not <bint>release)
 */
    __pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 13, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_INCREF(__pyx_v_version);
    __Pyx_GIVEREF(__pyx_v_version);
    PyList_SET_ITEM(__pyx_t_5, 0, __pyx_v_version);
    __Pyx_DECREF_SET(__pyx_v_out, __pyx_t_5);
    __pyx_t_5 = 0;

    /* "SLEPc/Sys.pyx":14
 *         if devel or date or author:
 *             out = [version]
 *             if devel:             # <<<<<<<<<<<<<<
 *                 out.append(not <bint>release)
 *             if date:
 */
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_devel); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(12, 14, __pyx_L1_error)
    if (__pyx_t_6) {

      /* "SLEPc/Sys.pyx":15
 *             out = [version]
 *             if devel:
 *                 out.append(not <bint>release)             # <<<<<<<<<<<<<<
 *             if date:
 *                 vstr = bytes2str(cversion)
 */
      __pyx_t_5 = __Pyx_PyBool_FromLong((!((__pyx_v_release != 0) != 0))); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 15, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_8 = __Pyx_PyObject_Append(__pyx_v_out, __pyx_t_5); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(12, 15, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

      /* "SLEPc/Sys.pyx":14
 *         if devel or date or author:
 *             out = [version]
 *             if devel:             # <<<<<<<<<<<<<<
 *                 out.append(not <bint>release)
 *             if date:
 */
    }

    /* "SLEPc/Sys.pyx":16
 *             if devel:
 *                 out.append(not <bint>release)
 *             if date:             # <<<<<<<<<<<<<<
 *                 vstr = bytes2str(cversion)
 *                 if release != 0:
 */
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_date); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(12, 16, __pyx_L1_error)
    if (__pyx_t_6) {

      /* "SLEPc/Sys.pyx":17
 *                 out.append(not <bint>release)
 *             if date:
 *                 vstr = bytes2str(cversion)             # <<<<<<<<<<<<<<
 *                 if release != 0:
 *                     date = vstr.split(",", 1)[-1].strip()
 */
      __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_cversion); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 17, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_v_vstr = __pyx_t_5;
      __pyx_t_5 = 0;

      /* "SLEPc/Sys.pyx":18
 *             if date:
 *                 vstr = bytes2str(cversion)
 *                 if release != 0:             # <<<<<<<<<<<<<<
 *                     date = vstr.split(",", 1)[-1].strip()
 *                 else:
 */
      __pyx_t_6 = ((__pyx_v_release != 0) != 0);
      if (__pyx_t_6) {

        /* "SLEPc/Sys.pyx":19
 *                 vstr = bytes2str(cversion)
 *                 if release != 0:
 *                     date = vstr.split(",", 1)[-1].strip()             # <<<<<<<<<<<<<<
 *                 else:
 *                     date = vstr.split("GIT Date:")[-1].strip()
 */
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_vstr, __pyx_n_s_split); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 19, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 19, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_3, -1L, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 19, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_strip); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 19, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_4 = NULL;
        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
          __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
          if (likely(__pyx_t_4)) {
            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(function);
            __Pyx_DECREF_SET(__pyx_t_3, function);
          }
        }
        __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 19, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF_SET(__pyx_v_date, __pyx_t_5);
        __pyx_t_5 = 0;

        /* "SLEPc/Sys.pyx":18
 *             if date:
 *                 vstr = bytes2str(cversion)
 *                 if release != 0:             # <<<<<<<<<<<<<<
 *                     date = vstr.split(",", 1)[-1].strip()
 *                 else:
 */
        goto __pyx_L9;
      }

      /* "SLEPc/Sys.pyx":21
 *                     date = vstr.split(",", 1)[-1].strip()
 *                 else:
 *                     date = vstr.split("GIT Date:")[-1].strip()             # <<<<<<<<<<<<<<
 *                 out.append(date)
 *             if author:
 */
      /*else*/ {
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_vstr, __pyx_n_s_split); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 21, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_2 = NULL;
        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
          if (likely(__pyx_t_2)) {
            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
            __Pyx_INCREF(__pyx_t_2);
            __Pyx_INCREF(function);
            __Pyx_DECREF_SET(__pyx_t_4, function);
          }
        }
        __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_2, __pyx_kp_s_GIT_Date) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_s_GIT_Date);
        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 21, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_3, -1L, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 21, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_strip); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 21, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __pyx_t_4 = NULL;
        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
          __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
          if (likely(__pyx_t_4)) {
            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(function);
            __Pyx_DECREF_SET(__pyx_t_3, function);
          }
        }
        __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 21, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_DECREF_SET(__pyx_v_date, __pyx_t_5);
        __pyx_t_5 = 0;
      }
      __pyx_L9:;

      /* "SLEPc/Sys.pyx":22
 *                 else:
 *                     date = vstr.split("GIT Date:")[-1].strip()
 *                 out.append(date)             # <<<<<<<<<<<<<<
 *             if author:
 *                 author = bytes2str(SLEPC_AUTHOR_INFO).split('\n')
 */
      __pyx_t_8 = __Pyx_PyObject_Append(__pyx_v_out, __pyx_v_date); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(12, 22, __pyx_L1_error)

      /* "SLEPc/Sys.pyx":16
 *             if devel:
 *                 out.append(not <bint>release)
 *             if date:             # <<<<<<<<<<<<<<
 *                 vstr = bytes2str(cversion)
 *                 if release != 0:
 */
    }

    /* "SLEPc/Sys.pyx":23
 *                     date = vstr.split("GIT Date:")[-1].strip()
 *                 out.append(date)
 *             if author:             # <<<<<<<<<<<<<<
 *                 author = bytes2str(SLEPC_AUTHOR_INFO).split('\n')
 *                 author = tuple([s.strip() for s in author if s])
 */
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_author); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(12, 23, __pyx_L1_error)
    if (__pyx_t_6) {

      /* "SLEPc/Sys.pyx":24
 *                 out.append(date)
 *             if author:
 *                 author = bytes2str(SLEPC_AUTHOR_INFO).split('\n')             # <<<<<<<<<<<<<<
 *                 author = tuple([s.strip() for s in author if s])
 *                 out.append(author)
 */
      __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_bytes2str(SLEPC_AUTHOR_INFO); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 24, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_split); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 24, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = NULL;
      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
        if (likely(__pyx_t_3)) {
          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_3);
          __Pyx_INCREF(function);
          __Pyx_DECREF_SET(__pyx_t_4, function);
        }
      }
      __pyx_t_5 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_3, __pyx_kp_s__4) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_s__4);
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 24, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF_SET(__pyx_v_author, __pyx_t_5);
      __pyx_t_5 = 0;

      /* "SLEPc/Sys.pyx":25
 *             if author:
 *                 author = bytes2str(SLEPC_AUTHOR_INFO).split('\n')
 *                 author = tuple([s.strip() for s in author if s])             # <<<<<<<<<<<<<<
 *                 out.append(author)
 *         return tuple(out)
 */
      { /* enter inner scope */
        __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 25, __pyx_L13_error)
        __Pyx_GOTREF(__pyx_t_5);
        if (likely(PyList_CheckExact(__pyx_v_author)) || PyTuple_CheckExact(__pyx_v_author)) {
          __pyx_t_4 = __pyx_v_author; __Pyx_INCREF(__pyx_t_4); __pyx_t_9 = 0;
          __pyx_t_10 = NULL;
        } else {
          __pyx_t_9 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_author); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 25, __pyx_L13_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_10 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(12, 25, __pyx_L13_error)
        }
        for (;;) {
          if (likely(!__pyx_t_10)) {
            if (likely(PyList_CheckExact(__pyx_t_4))) {
              if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_4)) break;
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              __pyx_t_3 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_3); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(12, 25, __pyx_L13_error)
              #else
              __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 25, __pyx_L13_error)
              __Pyx_GOTREF(__pyx_t_3);
              #endif
            } else {
              if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_3); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(12, 25, __pyx_L13_error)
              #else
              __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 25, __pyx_L13_error)
              __Pyx_GOTREF(__pyx_t_3);
              #endif
            }
          } else {
            __pyx_t_3 = __pyx_t_10(__pyx_t_4);
            if (unlikely(!__pyx_t_3)) {
              PyObject* exc_type = PyErr_Occurred();
              if (exc_type) {
                if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
                else __PYX_ERR(12, 25, __pyx_L13_error)
              }
              break;
            }
            __Pyx_GOTREF(__pyx_t_3);
          }
          __Pyx_XDECREF_SET(__pyx_8genexpr8__pyx_v_s, __pyx_t_3);
          __pyx_t_3 = 0;
          __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_8genexpr8__pyx_v_s); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(12, 25, __pyx_L13_error)
          if (__pyx_t_6) {
            __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_8genexpr8__pyx_v_s, __pyx_n_s_strip); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 25, __pyx_L13_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_11 = NULL;
            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
              __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_2);
              if (likely(__pyx_t_11)) {
                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
                __Pyx_INCREF(__pyx_t_11);
                __Pyx_INCREF(function);
                __Pyx_DECREF_SET(__pyx_t_2, function);
              }
            }
            __pyx_t_3 = (__pyx_t_11) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_11) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
            __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 25, __pyx_L13_error)
            __Pyx_GOTREF(__pyx_t_3);
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            if (unlikely(__Pyx_ListComp_Append(__pyx_t_5, (PyObject*)__pyx_t_3))) __PYX_ERR(12, 25, __pyx_L13_error)
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          }
        }
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_XDECREF(__pyx_8genexpr8__pyx_v_s); __pyx_8genexpr8__pyx_v_s = 0;
        goto __pyx_L17_exit_scope;
        __pyx_L13_error:;
        __Pyx_XDECREF(__pyx_8genexpr8__pyx_v_s); __pyx_8genexpr8__pyx_v_s = 0;
        goto __pyx_L1_error;
        __pyx_L17_exit_scope:;
      } /* exit inner scope */
      __pyx_t_4 = PyList_AsTuple(((PyObject*)__pyx_t_5)); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 25, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_DECREF_SET(__pyx_v_author, __pyx_t_4);
      __pyx_t_4 = 0;

      /* "SLEPc/Sys.pyx":26
 *                 author = bytes2str(SLEPC_AUTHOR_INFO).split('\n')
 *                 author = tuple([s.strip() for s in author if s])
 *                 out.append(author)             # <<<<<<<<<<<<<<
 *         return tuple(out)
 * 
 */
      __pyx_t_8 = __Pyx_PyObject_Append(__pyx_v_out, __pyx_v_author); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(12, 26, __pyx_L1_error)

      /* "SLEPc/Sys.pyx":23
 *                     date = vstr.split("GIT Date:")[-1].strip()
 *                 out.append(date)
 *             if author:             # <<<<<<<<<<<<<<
 *                 author = bytes2str(SLEPC_AUTHOR_INFO).split('\n')
 *                 author = tuple([s.strip() for s in author if s])
 */
    }

    /* "SLEPc/Sys.pyx":12
 *         CHKERR( SlepcGetVersionNumber(&major, &minor, &micro, &release) )
 *         out = version = (toInt(major), toInt(minor), toInt(micro))
 *         if devel or date or author:             # <<<<<<<<<<<<<<
 *             out = [version]
 *             if devel:
 */
  }

  /* "SLEPc/Sys.pyx":27
 *                 author = tuple([s.strip() for s in author if s])
 *                 out.append(author)
 *         return tuple(out)             # <<<<<<<<<<<<<<
 * 
 *     @classmethod
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_out); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 27, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/Sys.pyx":6
 * 
 *     @classmethod
 *     def getVersion(cls, devel=False, date=False, author=False):             # <<<<<<<<<<<<<<
 *         cdef char cversion[256]
 *         cdef PetscInt major=0, minor=0, micro=0, release=0
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("slepc4py.SLEPc.Sys.getVersion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_out);
  __Pyx_XDECREF(__pyx_v_version);
  __Pyx_XDECREF(__pyx_v_vstr);
  __Pyx_XDECREF(__pyx_8genexpr8__pyx_v_s);
  __Pyx_XDECREF(__pyx_v_date);
  __Pyx_XDECREF(__pyx_v_author);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/Sys.pyx":30
 * 
 *     @classmethod
 *     def getVersionInfo(cls):             # <<<<<<<<<<<<<<
 *         version, dev, date, author = cls.getVersion(True, True, True)
 *         return dict(major      = version[0],
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3Sys_3getVersionInfo(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3Sys_2getVersionInfo[] = "Sys.getVersionInfo(type cls)";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3Sys_3getVersionInfo(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getVersionInfo (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getVersionInfo", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getVersionInfo", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3Sys_2getVersionInfo(((PyTypeObject*)__pyx_v_cls));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3Sys_2getVersionInfo(PyTypeObject *__pyx_v_cls) {
  PyObject *__pyx_v_version = NULL;
  PyObject *__pyx_v_dev = NULL;
  PyObject *__pyx_v_date = NULL;
  PyObject *__pyx_v_author = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *(*__pyx_t_7)(PyObject *);
  int __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getVersionInfo", 0);

  /* "SLEPc/Sys.pyx":31
 *     @classmethod
 *     def getVersionInfo(cls):
 *         version, dev, date, author = cls.getVersion(True, True, True)             # <<<<<<<<<<<<<<
 *         return dict(major      = version[0],
 *                     minor      = version[1],
 */
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_cls), __pyx_n_s_getVersion); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 31, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 31, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
    PyObject* sequence = __pyx_t_2;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 4)) {
      if (size > 4) __Pyx_RaiseTooManyValuesError(4);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(12, 31, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); 
      __pyx_t_5 = PyTuple_GET_ITEM(sequence, 3); 
    } else {
      __pyx_t_1 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
      __pyx_t_4 = PyList_GET_ITEM(sequence, 2); 
      __pyx_t_5 = PyList_GET_ITEM(sequence, 3); 
    }
    __Pyx_INCREF(__pyx_t_1);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_5);
    #else
    {
      Py_ssize_t i;
      PyObject** temps[4] = {&__pyx_t_1,&__pyx_t_3,&__pyx_t_4,&__pyx_t_5};
      for (i=0; i < 4; i++) {
        PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(12, 31, __pyx_L1_error)
        __Pyx_GOTREF(item);
        *(temps[i]) = item;
      }
    }
    #endif
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  } else {
    Py_ssize_t index = -1;
    PyObject** temps[4] = {&__pyx_t_1,&__pyx_t_3,&__pyx_t_4,&__pyx_t_5};
    __pyx_t_6 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 31, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext;
    for (index=0; index < 4; index++) {
      PyObject* item = __pyx_t_7(__pyx_t_6); if (unlikely(!item)) goto __pyx_L3_unpacking_failed;
      __Pyx_GOTREF(item);
      *(temps[index]) = item;
    }
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 4) < 0) __PYX_ERR(12, 31, __pyx_L1_error)
    __pyx_t_7 = NULL;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    goto __pyx_L4_unpacking_done;
    __pyx_L3_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_7 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(12, 31, __pyx_L1_error)
    __pyx_L4_unpacking_done:;
  }
  __pyx_v_version = __pyx_t_1;
  __pyx_t_1 = 0;
  __pyx_v_dev = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_date = __pyx_t_4;
  __pyx_t_4 = 0;
  __pyx_v_author = __pyx_t_5;
  __pyx_t_5 = 0;

  /* "SLEPc/Sys.pyx":32
 *     def getVersionInfo(cls):
 *         version, dev, date, author = cls.getVersion(True, True, True)
 *         return dict(major      = version[0],             # <<<<<<<<<<<<<<
 *                     minor      = version[1],
 *                     subminor   = version[2],
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 32, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_version, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 32, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_major, __pyx_t_5) < 0) __PYX_ERR(12, 32, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

  /* "SLEPc/Sys.pyx":33
 *         version, dev, date, author = cls.getVersion(True, True, True)
 *         return dict(major      = version[0],
 *                     minor      = version[1],             # <<<<<<<<<<<<<<
 *                     subminor   = version[2],
 *                     release    = not dev,
 */
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_version, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 33, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_minor, __pyx_t_5) < 0) __PYX_ERR(12, 32, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

  /* "SLEPc/Sys.pyx":34
 *         return dict(major      = version[0],
 *                     minor      = version[1],
 *                     subminor   = version[2],             # <<<<<<<<<<<<<<
 *                     release    = not dev,
 *                     date       = date,
 */
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_version, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 34, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_subminor, __pyx_t_5) < 0) __PYX_ERR(12, 32, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

  /* "SLEPc/Sys.pyx":35
 *                     minor      = version[1],
 *                     subminor   = version[2],
 *                     release    = not dev,             # <<<<<<<<<<<<<<
 *                     date       = date,
 *                     authorinfo = author)
 */
  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_dev); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(12, 35, __pyx_L1_error)
  __pyx_t_5 = __Pyx_PyBool_FromLong((!__pyx_t_8)); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 35, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_release, __pyx_t_5) < 0) __PYX_ERR(12, 32, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

  /* "SLEPc/Sys.pyx":36
 *                     subminor   = version[2],
 *                     release    = not dev,
 *                     date       = date,             # <<<<<<<<<<<<<<
 *                     authorinfo = author)
 * 
 */
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_date, __pyx_v_date) < 0) __PYX_ERR(12, 32, __pyx_L1_error)

  /* "SLEPc/Sys.pyx":37
 *                     release    = not dev,
 *                     date       = date,
 *                     authorinfo = author)             # <<<<<<<<<<<<<<
 * 
 *     # --- xxx ---
 */
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_authorinfo, __pyx_v_author) < 0) __PYX_ERR(12, 32, __pyx_L1_error)
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/Sys.pyx":30
 * 
 *     @classmethod
 *     def getVersionInfo(cls):             # <<<<<<<<<<<<<<
 *         version, dev, date, author = cls.getVersion(True, True, True)
 *         return dict(major      = version[0],
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("slepc4py.SLEPc.Sys.getVersionInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_version);
  __Pyx_XDECREF(__pyx_v_dev);
  __Pyx_XDECREF(__pyx_v_date);
  __Pyx_XDECREF(__pyx_v_author);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/Sys.pyx":42
 * 
 *     @classmethod
 *     def isInitialized(cls):             # <<<<<<<<<<<<<<
 *         return toBool(SlepcInitializeCalled)
 * 
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3Sys_5isInitialized(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3Sys_4isInitialized[] = "Sys.isInitialized(type cls)";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3Sys_5isInitialized(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("isInitialized (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("isInitialized", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isInitialized", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3Sys_4isInitialized(((PyTypeObject*)__pyx_v_cls));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3Sys_4isInitialized(CYTHON_UNUSED PyTypeObject *__pyx_v_cls) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("isInitialized", 0);

  /* "SLEPc/Sys.pyx":43
 *     @classmethod
 *     def isInitialized(cls):
 *         return toBool(SlepcInitializeCalled)             # <<<<<<<<<<<<<<
 * 
 *     @classmethod
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_toBool(SlepcInitializeCalled); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 43, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/Sys.pyx":42
 * 
 *     @classmethod
 *     def isInitialized(cls):             # <<<<<<<<<<<<<<
 *         return toBool(SlepcInitializeCalled)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.Sys.isInitialized", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/Sys.pyx":46
 * 
 *     @classmethod
 *     def isFinalized(cls):             # <<<<<<<<<<<<<<
 *         return toBool(SlepcFinalizeCalled)
 * 
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3Sys_7isFinalized(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3Sys_6isFinalized[] = "Sys.isFinalized(type cls)";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3Sys_7isFinalized(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("isFinalized (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("isFinalized", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isFinalized", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3Sys_6isFinalized(((PyTypeObject*)__pyx_v_cls));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3Sys_6isFinalized(CYTHON_UNUSED PyTypeObject *__pyx_v_cls) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("isFinalized", 0);

  /* "SLEPc/Sys.pyx":47
 *     @classmethod
 *     def isFinalized(cls):
 *         return toBool(SlepcFinalizeCalled)             # <<<<<<<<<<<<<<
 * 
 *     # --- xxx ---
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_toBool(SlepcFinalizeCalled); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 47, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/Sys.pyx":46
 * 
 *     @classmethod
 *     def isFinalized(cls):             # <<<<<<<<<<<<<<
 *         return toBool(SlepcFinalizeCalled)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.Sys.isFinalized", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/Sys.pyx":52
 * 
 *     @classmethod
 *     def hasExternalPackage(cls, package):             # <<<<<<<<<<<<<<
 *         cdef const char *cpackage = NULL
 *         package = str2bytes(package, &cpackage)
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3Sys_9hasExternalPackage(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3Sys_8hasExternalPackage[] = "Sys.hasExternalPackage(type cls, package)";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3Sys_9hasExternalPackage(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_package = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("hasExternalPackage (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_package,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_package)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "hasExternalPackage") < 0)) __PYX_ERR(12, 52, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_package = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("hasExternalPackage", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 52, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.Sys.hasExternalPackage", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3Sys_8hasExternalPackage(((PyTypeObject*)__pyx_v_cls), __pyx_v_package);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3Sys_8hasExternalPackage(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_package) {
  char const *__pyx_v_cpackage;
  PetscBool __pyx_v_has;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("hasExternalPackage", 0);
  __Pyx_INCREF(__pyx_v_package);

  /* "SLEPc/Sys.pyx":53
 *     @classmethod
 *     def hasExternalPackage(cls, package):
 *         cdef const char *cpackage = NULL             # <<<<<<<<<<<<<<
 *         package = str2bytes(package, &cpackage)
 *         cdef PetscBool has = PETSC_FALSE
 */
  __pyx_v_cpackage = NULL;

  /* "SLEPc/Sys.pyx":54
 *     def hasExternalPackage(cls, package):
 *         cdef const char *cpackage = NULL
 *         package = str2bytes(package, &cpackage)             # <<<<<<<<<<<<<<
 *         cdef PetscBool has = PETSC_FALSE
 *         CHKERR( SlepcHasExternalPackage(cpackage, &has) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_package, (&__pyx_v_cpackage)); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 54, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_package, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/Sys.pyx":55
 *         cdef const char *cpackage = NULL
 *         package = str2bytes(package, &cpackage)
 *         cdef PetscBool has = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( SlepcHasExternalPackage(cpackage, &has) )
 *         return toBool(has)
 */
  __pyx_v_has = PETSC_FALSE;

  /* "SLEPc/Sys.pyx":56
 *         package = str2bytes(package, &cpackage)
 *         cdef PetscBool has = PETSC_FALSE
 *         CHKERR( SlepcHasExternalPackage(cpackage, &has) )             # <<<<<<<<<<<<<<
 *         return toBool(has)
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SlepcHasExternalPackage(__pyx_v_cpackage, (&__pyx_v_has))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(12, 56, __pyx_L1_error)

  /* "SLEPc/Sys.pyx":57
 *         cdef PetscBool has = PETSC_FALSE
 *         CHKERR( SlepcHasExternalPackage(cpackage, &has) )
 *         return toBool(has)             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_has); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 57, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/Sys.pyx":52
 * 
 *     @classmethod
 *     def hasExternalPackage(cls, package):             # <<<<<<<<<<<<<<
 *         cdef const char *cpackage = NULL
 *         package = str2bytes(package, &cpackage)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.Sys.hasExternalPackage", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_package);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":45
 *     MatMode      = STMatMode
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.st
 *         self.st = NULL
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2ST_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2ST_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST___cinit__(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2ST___cinit__(struct PySlepcSTObject *__pyx_v_self) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "SLEPc/ST.pyx":46
 * 
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.st             # <<<<<<<<<<<<<<
 *         self.st = NULL
 * 
 */
  __pyx_v_self->__pyx_base.obj = ((PetscObject *)(&__pyx_v_self->st));

  /* "SLEPc/ST.pyx":47
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.st
 *         self.st = NULL             # <<<<<<<<<<<<<<
 * 
 *     def view(self, Viewer viewer=None):
 */
  __pyx_v_self->st = NULL;

  /* "SLEPc/ST.pyx":45
 *     MatMode      = STMatMode
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.st
 *         self.st = NULL
 */

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":49
 *         self.st = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the ST data structure.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_2view[] = "ST.view(self, Viewer viewer=None)\n\n        Prints the ST data structure.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("view (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "view") < 0)) __PYX_ERR(0, 49, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("view", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 49, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(0, 49, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_2view(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_2view(struct PySlepcSTObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("view", 0);

  /* "SLEPc/ST.pyx":59
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( STView(self.st, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/ST.pyx":60
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( STView(self.st, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def destroy(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STView(__pyx_v_self->st, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 60, __pyx_L1_error)

  /* "SLEPc/ST.pyx":49
 *         self.st = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the ST data structure.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":62
 *         CHKERR( STView(self.st, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the ST object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_4destroy[] = "ST.destroy(self)\n\n        Destroys the ST object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("destroy (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("destroy", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "destroy", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_4destroy(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_4destroy(struct PySlepcSTObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("destroy", 0);

  /* "SLEPc/ST.pyx":66
 *         Destroys the ST object.
 *         """
 *         CHKERR( STDestroy(&self.st) )             # <<<<<<<<<<<<<<
 *         self.st = NULL
 *         return self
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STDestroy((&__pyx_v_self->st))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 66, __pyx_L1_error)

  /* "SLEPc/ST.pyx":67
 *         """
 *         CHKERR( STDestroy(&self.st) )
 *         self.st = NULL             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  __pyx_v_self->st = NULL;

  /* "SLEPc/ST.pyx":68
 *         CHKERR( STDestroy(&self.st) )
 *         self.st = NULL
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def reset(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":62
 *         CHKERR( STView(self.st, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the ST object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.destroy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":70
 *         return self
 * 
 *     def reset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Resets the ST object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_7reset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_6reset[] = "ST.reset(self)\n\n        Resets the ST object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_7reset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("reset (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("reset", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "reset", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_6reset(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_6reset(struct PySlepcSTObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("reset", 0);

  /* "SLEPc/ST.pyx":74
 *         Resets the ST object.
 *         """
 *         CHKERR( STReset(self.st) )             # <<<<<<<<<<<<<<
 * 
 *     def create(self, comm=None):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STReset(__pyx_v_self->st)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 74, __pyx_L1_error)

  /* "SLEPc/ST.pyx":70
 *         return self
 * 
 *     def reset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Resets the ST object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.reset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":76
 *         CHKERR( STReset(self.st) )
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the ST object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_9create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_8create[] = "ST.create(self, comm=None)\n\n        Creates the ST object.\n\n        Parameters\n        ----------\n        comm: Comm, optional\n              MPI communicator; if not provided, it defaults to all\n              processes.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_9create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comm = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comm,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comm);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create") < 0)) __PYX_ERR(0, 76, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_comm = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("create", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 76, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_8create(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_comm);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_8create(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_comm) {
  MPI_Comm __pyx_v_ccomm;
  ST __pyx_v_newst;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  MPI_Comm __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("create", 0);

  /* "SLEPc/ST.pyx":86
 *               processes.
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())             # <<<<<<<<<<<<<<
 *         cdef SlepcST newst = NULL
 *         CHKERR( STCreate(ccomm, &newst) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_def_Comm(__pyx_v_comm, __pyx_f_8slepc4py_5SLEPc_SLEPC_COMM_DEFAULT()); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error)
  __pyx_v_ccomm = __pyx_t_1;

  /* "SLEPc/ST.pyx":87
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcST newst = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( STCreate(ccomm, &newst) )
 *         SlepcCLEAR(self.obj); self.st = newst
 */
  __pyx_v_newst = NULL;

  /* "SLEPc/ST.pyx":88
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcST newst = NULL
 *         CHKERR( STCreate(ccomm, &newst) )             # <<<<<<<<<<<<<<
 *         SlepcCLEAR(self.obj); self.st = newst
 *         return self
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STCreate(__pyx_v_ccomm, (&__pyx_v_newst))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 88, __pyx_L1_error)

  /* "SLEPc/ST.pyx":89
 *         cdef SlepcST newst = NULL
 *         CHKERR( STCreate(ccomm, &newst) )
 *         SlepcCLEAR(self.obj); self.st = newst             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_SlepcCLEAR(__pyx_v_self->__pyx_base.obj));
  __pyx_v_self->st = __pyx_v_newst;

  /* "SLEPc/ST.pyx":90
 *         CHKERR( STCreate(ccomm, &newst) )
 *         SlepcCLEAR(self.obj); self.st = newst
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def setType(self, st_type):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":76
 *         CHKERR( STReset(self.st) )
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the ST object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":92
 *         return self
 * 
 *     def setType(self, st_type):             # <<<<<<<<<<<<<<
 *         """
 *         Builds ST for a particular spectral transformation.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_11setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_10setType[] = "ST.setType(self, st_type)\n\n        Builds ST for a particular spectral transformation.\n\n        Parameters\n        ----------\n        st_type: `ST.Type` enumerate\n                 The spectral transformation to be used.\n\n        Notes\n        -----\n        See `ST.Type` for available methods. The default is\n        `ST.Type.SHIFT` with a zero shift.  Normally, it is best to\n        use `setFromOptions()` and then set the ST type from the\n        options database rather than by using this routine.  Using the\n        options database provides the user with maximum flexibility in\n        evaluating the different available methods.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_11setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_st_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_st_type,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_st_type)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setType") < 0)) __PYX_ERR(0, 92, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_st_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 92, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_10setType(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_st_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_10setType(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_st_type) {
  const char* __pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setType", 0);
  __Pyx_INCREF(__pyx_v_st_type);

  /* "SLEPc/ST.pyx":110
 *         evaluating the different available methods.
 *         """
 *         cdef SlepcSTType cval = NULL             # <<<<<<<<<<<<<<
 *         st_type = str2bytes(st_type, &cval)
 *         CHKERR( STSetType(self.st, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/ST.pyx":111
 *         """
 *         cdef SlepcSTType cval = NULL
 *         st_type = str2bytes(st_type, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( STSetType(self.st, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_st_type, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_st_type, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/ST.pyx":112
 *         cdef SlepcSTType cval = NULL
 *         st_type = str2bytes(st_type, &cval)
 *         CHKERR( STSetType(self.st, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getType(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STSetType(__pyx_v_self->st, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 112, __pyx_L1_error)

  /* "SLEPc/ST.pyx":92
 *         return self
 * 
 *     def setType(self, st_type):             # <<<<<<<<<<<<<<
 *         """
 *         Builds ST for a particular spectral transformation.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_st_type);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":114
 *         CHKERR( STSetType(self.st, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the ST type of this object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_13getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_12getType[] = "ST.getType(self)\n\n        Gets the ST type of this object.\n\n        Returns\n        -------\n        type: `ST.Type` enumerate\n              The spectral transformation currently being used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_13getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_12getType(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_12getType(struct PySlepcSTObject *__pyx_v_self) {
  const char* __pyx_v_st_type;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getType", 0);

  /* "SLEPc/ST.pyx":123
 *               The spectral transformation currently being used.
 *         """
 *         cdef SlepcSTType st_type = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( STGetType(self.st, &st_type) )
 *         return bytes2str(st_type)
 */
  __pyx_v_st_type = NULL;

  /* "SLEPc/ST.pyx":124
 *         """
 *         cdef SlepcSTType st_type = NULL
 *         CHKERR( STGetType(self.st, &st_type) )             # <<<<<<<<<<<<<<
 *         return bytes2str(st_type)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STGetType(__pyx_v_self->st, (&__pyx_v_st_type))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 124, __pyx_L1_error)

  /* "SLEPc/ST.pyx":125
 *         cdef SlepcSTType st_type = NULL
 *         CHKERR( STGetType(self.st, &st_type) )
 *         return bytes2str(st_type)             # <<<<<<<<<<<<<<
 * 
 *     def setOptionsPrefix(self, prefix):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_st_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":114
 *         CHKERR( STSetType(self.st, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the ST type of this object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.getType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":127
 *         return bytes2str(st_type)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all ST options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_15setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_14setOptionsPrefix[] = "ST.setOptionsPrefix(self, prefix)\n\n        Sets the prefix used for searching for all ST options in the\n        database.\n\n        Parameters\n        ----------\n        prefix: string\n                The prefix string to prepend to all ST option\n                requests.\n\n        Notes\n        -----\n        A hyphen (``-``) must NOT be given at the beginning of the\n        prefix name.  The first character of all runtime options is\n        AUTOMATICALLY the hyphen.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_15setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOptionsPrefix") < 0)) __PYX_ERR(0, 127, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 127, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_14setOptionsPrefix(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_14setOptionsPrefix(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/ST.pyx":144
 *         AUTOMATICALLY the hyphen.
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( STSetOptionsPrefix(self.st, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/ST.pyx":145
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( STSetOptionsPrefix(self.st, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/ST.pyx":146
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( STSetOptionsPrefix(self.st, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getOptionsPrefix(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STSetOptionsPrefix(__pyx_v_self->st, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 146, __pyx_L1_error)

  /* "SLEPc/ST.pyx":127
 *         return bytes2str(st_type)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all ST options in the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":148
 *         CHKERR( STSetOptionsPrefix(self.st, cval) )
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all ST options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_17getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_16getOptionsPrefix[] = "ST.getOptionsPrefix(self)\n\n        Gets the prefix used for searching for all ST options in the\n        database.\n\n        Returns\n        -------\n        prefix: string\n                The prefix string set for this ST object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_17getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOptionsPrefix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOptionsPrefix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOptionsPrefix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_16getOptionsPrefix(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_16getOptionsPrefix(struct PySlepcSTObject *__pyx_v_self) {
  const char *__pyx_v_prefix;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOptionsPrefix", 0);

  /* "SLEPc/ST.pyx":158
 *                 The prefix string set for this ST object.
 *         """
 *         cdef const_char *prefix = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( STGetOptionsPrefix(self.st, &prefix) )
 *         return bytes2str(prefix)
 */
  __pyx_v_prefix = NULL;

  /* "SLEPc/ST.pyx":159
 *         """
 *         cdef const_char *prefix = NULL
 *         CHKERR( STGetOptionsPrefix(self.st, &prefix) )             # <<<<<<<<<<<<<<
 *         return bytes2str(prefix)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STGetOptionsPrefix(__pyx_v_self->st, (&__pyx_v_prefix))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 159, __pyx_L1_error)

  /* "SLEPc/ST.pyx":160
 *         cdef const_char *prefix = NULL
 *         CHKERR( STGetOptionsPrefix(self.st, &prefix) )
 *         return bytes2str(prefix)             # <<<<<<<<<<<<<<
 * 
 *     def setFromOptions(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_prefix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":148
 *         CHKERR( STSetOptionsPrefix(self.st, cval) )
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all ST options in the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.getOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":162
 *         return bytes2str(prefix)
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets ST options from the options database. This routine must
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_19setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_18setFromOptions[] = "ST.setFromOptions(self)\n\n        Sets ST options from the options database. This routine must\n        be called before `setUp()` if the user is to be allowed to set\n        the solver type.\n\n        Notes\n        -----\n        To see all options, run your program with the -help option.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_19setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFromOptions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setFromOptions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setFromOptions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_18setFromOptions(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_18setFromOptions(struct PySlepcSTObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFromOptions", 0);

  /* "SLEPc/ST.pyx":172
 *         To see all options, run your program with the -help option.
 *         """
 *         CHKERR( STSetFromOptions(self.st) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STSetFromOptions(__pyx_v_self->st)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 172, __pyx_L1_error)

  /* "SLEPc/ST.pyx":162
 *         return bytes2str(prefix)
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets ST options from the options database. This routine must
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setFromOptions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":176
 *     #
 * 
 *     def setShift(self, shift):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the shift associated with the spectral transformation.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_21setShift(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_20setShift[] = "ST.setShift(self, shift)\n\n        Sets the shift associated with the spectral transformation.\n\n        Parameters\n        ----------\n        shift: scalar (possibly complex)\n               The value of the shift.\n\n        Notes\n        -----\n        In some spectral transformations, changing the shift may have\n        associated a lot of work, for example recomputing a\n        factorization.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_21setShift(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_shift = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setShift (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shift,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shift)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setShift") < 0)) __PYX_ERR(0, 176, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_shift = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setShift", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 176, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setShift", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_20setShift(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_shift);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_20setShift(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_shift) {
  PetscScalar __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setShift", 0);

  /* "SLEPc/ST.pyx":191
 *         factorization.
 *         """
 *         cdef PetscScalar sval = asScalar(shift)             # <<<<<<<<<<<<<<
 *         CHKERR( STSetShift(self.st, sval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_shift); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(0, 191, __pyx_L1_error)
  __pyx_v_sval = __pyx_t_1;

  /* "SLEPc/ST.pyx":192
 *         """
 *         cdef PetscScalar sval = asScalar(shift)
 *         CHKERR( STSetShift(self.st, sval) )             # <<<<<<<<<<<<<<
 * 
 *     def getShift(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STSetShift(__pyx_v_self->st, __pyx_v_sval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 192, __pyx_L1_error)

  /* "SLEPc/ST.pyx":176
 *     #
 * 
 *     def setShift(self, shift):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the shift associated with the spectral transformation.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setShift", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":194
 *         CHKERR( STSetShift(self.st, sval) )
 * 
 *     def getShift(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the shift associated with the spectral transformation.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_23getShift(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_22getShift[] = "ST.getShift(self)\n\n        Gets the shift associated with the spectral transformation.\n\n        Returns\n        -------\n        shift: scalar (possibly complex)\n               The value of the shift.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_23getShift(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getShift (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getShift", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getShift", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_22getShift(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_22getShift(struct PySlepcSTObject *__pyx_v_self) {
  PetscScalar __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getShift", 0);

  /* "SLEPc/ST.pyx":203
 *                The value of the shift.
 *         """
 *         cdef PetscScalar sval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( STGetShift(self.st, &sval) )
 *         return toScalar(sval)
 */
  __pyx_v_sval = 0.0;

  /* "SLEPc/ST.pyx":204
 *         """
 *         cdef PetscScalar sval = 0
 *         CHKERR( STGetShift(self.st, &sval) )             # <<<<<<<<<<<<<<
 *         return toScalar(sval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STGetShift(__pyx_v_self->st, (&__pyx_v_sval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 204, __pyx_L1_error)

  /* "SLEPc/ST.pyx":205
 *         cdef PetscScalar sval = 0
 *         CHKERR( STGetShift(self.st, &sval) )
 *         return toScalar(sval)             # <<<<<<<<<<<<<<
 * 
 *     def setTransform(self, flag=True):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_sval); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":194
 *         CHKERR( STSetShift(self.st, sval) )
 * 
 *     def getShift(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the shift associated with the spectral transformation.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.getShift", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":207
 *         return toScalar(sval)
 * 
 *     def setTransform(self, flag=True):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to indicate whether the transformed matrices
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_25setTransform(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_24setTransform[] = "ST.setTransform(self, flag=True)\n\n        Sets a flag to indicate whether the transformed matrices\n        are computed or not.\n\n        Parameters\n        ----------\n        flag: bool, optional\n              This flag is intended for the case of polynomial\n              eigenproblems solved via linearization.\n              If this flag is False (default) the spectral transformation\n              is applied to the linearization (handled by the eigensolver),\n              otherwise it is applied to the original problem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_25setTransform(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_flag = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTransform (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flag,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flag);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTransform") < 0)) __PYX_ERR(0, 207, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_flag = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTransform", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 207, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setTransform", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_24setTransform(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_flag);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_24setTransform(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_flag) {
  PetscBool __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTransform", 0);

  /* "SLEPc/ST.pyx":221
 *               otherwise it is applied to the original problem.
 *         """
 *         cdef PetscBool sval = asBool(flag)             # <<<<<<<<<<<<<<
 *         CHKERR( STSetTransform(self.st, sval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_flag); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(0, 221, __pyx_L1_error)
  __pyx_v_sval = __pyx_t_1;

  /* "SLEPc/ST.pyx":222
 *         """
 *         cdef PetscBool sval = asBool(flag)
 *         CHKERR( STSetTransform(self.st, sval) )             # <<<<<<<<<<<<<<
 * 
 *     def getTransform(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STSetTransform(__pyx_v_self->st, __pyx_v_sval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 222, __pyx_L1_error)

  /* "SLEPc/ST.pyx":207
 *         return toScalar(sval)
 * 
 *     def setTransform(self, flag=True):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to indicate whether the transformed matrices
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setTransform", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":224
 *         CHKERR( STSetTransform(self.st, sval) )
 * 
 *     def getTransform(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the flag indicating whether the transformed matrices
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_27getTransform(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_26getTransform[] = "ST.getTransform(self)\n\n        Gets the flag indicating whether the transformed matrices\n        are computed or not.\n\n        Returns\n        -------\n        flag: bool\n               This flag is intended for the case of polynomial\n               eigenproblems solved via linearization.\n               If this flag is False (default) the spectral transformation\n               is applied to the linearization (handled by the eigensolver),\n               otherwise it is applied to the original problem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_27getTransform(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTransform (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTransform", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTransform", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_26getTransform(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_26getTransform(struct PySlepcSTObject *__pyx_v_self) {
  PetscBool __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTransform", 0);

  /* "SLEPc/ST.pyx":238
 *                otherwise it is applied to the original problem.
 *         """
 *         cdef PetscBool sval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( STGetTransform(self.st, &sval) )
 *         return toBool(sval)
 */
  __pyx_v_sval = PETSC_FALSE;

  /* "SLEPc/ST.pyx":239
 *         """
 *         cdef PetscBool sval = PETSC_FALSE
 *         CHKERR( STGetTransform(self.st, &sval) )             # <<<<<<<<<<<<<<
 *         return toBool(sval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STGetTransform(__pyx_v_self->st, (&__pyx_v_sval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 239, __pyx_L1_error)

  /* "SLEPc/ST.pyx":240
 *         cdef PetscBool sval = PETSC_FALSE
 *         CHKERR( STGetTransform(self.st, &sval) )
 *         return toBool(sval)             # <<<<<<<<<<<<<<
 * 
 *     def setMatMode(self, mode):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_sval); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":224
 *         CHKERR( STSetTransform(self.st, sval) )
 * 
 *     def getTransform(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the flag indicating whether the transformed matrices
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.getTransform", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":242
 *         return toBool(sval)
 * 
 *     def setMatMode(self, mode):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to indicate how the matrix is being shifted in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_29setMatMode(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_28setMatMode[] = "ST.setMatMode(self, mode)\n\n        Sets a flag to indicate how the matrix is being shifted in the\n        shift-and-invert and Cayley spectral transformations.\n\n        Parameters\n        ----------\n        mode: `ST.MatMode` enumerate\n              The mode flag.\n\n        Notes\n        -----\n        By default (`ST.MatMode.COPY`), a copy of matrix ``A`` is made\n        and then this copy is shifted explicitly, e.g. ``A <- (A - s\n        B)``.\n\n        With `ST.MatMode.INPLACE`, the original matrix ``A`` is\n        shifted at `setUp()` and unshifted at the end of the\n        computations. With respect to the previous one, this mode\n        avoids a copy of matrix ``A``. However, a backdraw is that the\n        recovered matrix might be slightly different from the original\n        one (due to roundoff).\n\n        With `ST.MatMode.SHELL`, the solver works with an implicit\n        shell matrix that represents the shifted matrix. This mode is\n        the most efficient in creating the shifted matrix but it\n        places serious limitations to the linear solves performed in\n        each iteration of the eigensolver (typically, only iterative\n        solvers with Jacobi preconditioning can be used).\n\n        In the case of generalized problems, in the two first modes\n        the matrix ``A - s B`` has to be computed explicitly. The\n        efficiency of this computation can be controlled with\n        `setMatStructure()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_29setMatMode(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_mode = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setMatMode (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_mode,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setMatMode") < 0)) __PYX_ERR(0, 242, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_mode = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setMatMode", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 242, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setMatMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_28setMatMode(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_mode);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_28setMatMode(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_mode) {
  STMatMode __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  STMatMode __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setMatMode", 0);

  /* "SLEPc/ST.pyx":277
 *         `setMatStructure()`.
 *         """
 *         cdef SlepcSTMatMode val = mode             # <<<<<<<<<<<<<<
 *         CHKERR( STSetMatMode(self.st, val) )
 * 
 */
  __pyx_t_1 = ((STMatMode)__Pyx_PyInt_As_STMatMode(__pyx_v_mode)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 277, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/ST.pyx":278
 *         """
 *         cdef SlepcSTMatMode val = mode
 *         CHKERR( STSetMatMode(self.st, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getMatMode(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STSetMatMode(__pyx_v_self->st, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 278, __pyx_L1_error)

  /* "SLEPc/ST.pyx":242
 *         return toBool(sval)
 * 
 *     def setMatMode(self, mode):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to indicate how the matrix is being shifted in the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setMatMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":280
 *         CHKERR( STSetMatMode(self.st, val) )
 * 
 *     def getMatMode(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets a flag that indicates how the matrix is being shifted in
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_31getMatMode(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_30getMatMode[] = "ST.getMatMode(self)\n\n        Gets a flag that indicates how the matrix is being shifted in\n        the shift-and-invert and Cayley spectral transformations.\n\n        Returns\n        -------\n        mode: `ST.MatMode` enumerate\n              The mode flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_31getMatMode(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getMatMode (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getMatMode", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getMatMode", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_30getMatMode(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_30getMatMode(struct PySlepcSTObject *__pyx_v_self) {
  STMatMode __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getMatMode", 0);

  /* "SLEPc/ST.pyx":290
 *               The mode flag.
 *         """
 *         cdef SlepcSTMatMode val = ST_MATMODE_INPLACE             # <<<<<<<<<<<<<<
 *         CHKERR( STGetMatMode(self.st, &val) )
 *         return val
 */
  __pyx_v_val = ST_MATMODE_INPLACE;

  /* "SLEPc/ST.pyx":291
 *         """
 *         cdef SlepcSTMatMode val = ST_MATMODE_INPLACE
 *         CHKERR( STGetMatMode(self.st, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STGetMatMode(__pyx_v_self->st, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 291, __pyx_L1_error)

  /* "SLEPc/ST.pyx":292
 *         cdef SlepcSTMatMode val = ST_MATMODE_INPLACE
 *         CHKERR( STGetMatMode(self.st, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setMatrices(self, operators):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_STMatMode(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 292, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":280
 *         CHKERR( STSetMatMode(self.st, val) )
 * 
 *     def getMatMode(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets a flag that indicates how the matrix is being shifted in
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.getMatMode", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":294
 *         return val
 * 
 *     def setMatrices(self, operators):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the matrices associated with the eigenvalue problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_33setMatrices(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_32setMatrices[] = "ST.setMatrices(self, operators)\n\n        Sets the matrices associated with the eigenvalue problem.\n\n        Parameters\n        ----------\n        operators: sequence of Mat\n           The matrices associated with the eigensystem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_33setMatrices(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_operators = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setMatrices (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_operators,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_operators)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setMatrices") < 0)) __PYX_ERR(0, 294, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_operators = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setMatrices", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 294, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setMatrices", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_32setMatrices(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_operators);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_32setMatrices(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_operators) {
  Mat *__pyx_v_mats;
  Py_ssize_t __pyx_v_k;
  Py_ssize_t __pyx_v_n;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  Py_ssize_t __pyx_t_2;
  Mat __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setMatrices", 0);
  __Pyx_INCREF(__pyx_v_operators);

  /* "SLEPc/ST.pyx":303
 *            The matrices associated with the eigensystem.
 *         """
 *         operators = tuple(operators)             # <<<<<<<<<<<<<<
 *         cdef PetscMat *mats = NULL
 *         cdef Py_ssize_t k=0, n = len(operators)
 */
  __pyx_t_1 = __Pyx_PySequence_Tuple(__pyx_v_operators); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 303, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_operators, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/ST.pyx":304
 *         """
 *         operators = tuple(operators)
 *         cdef PetscMat *mats = NULL             # <<<<<<<<<<<<<<
 *         cdef Py_ssize_t k=0, n = len(operators)
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscMat),<void**>&mats)
 */
  __pyx_v_mats = NULL;

  /* "SLEPc/ST.pyx":305
 *         operators = tuple(operators)
 *         cdef PetscMat *mats = NULL
 *         cdef Py_ssize_t k=0, n = len(operators)             # <<<<<<<<<<<<<<
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscMat),<void**>&mats)
 *         for k from 0 <= k < n: mats[k] = (<Mat?>operators[k]).mat
 */
  __pyx_v_k = 0;
  __pyx_t_2 = PyObject_Length(__pyx_v_operators); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 305, __pyx_L1_error)
  __pyx_v_n = __pyx_t_2;

  /* "SLEPc/ST.pyx":306
 *         cdef PetscMat *mats = NULL
 *         cdef Py_ssize_t k=0, n = len(operators)
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscMat),<void**>&mats)             # <<<<<<<<<<<<<<
 *         for k from 0 <= k < n: mats[k] = (<Mat?>operators[k]).mat
 *         CHKERR( STSetMatrices(self.st, <PetscInt>n, mats) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_n) * (sizeof(Mat))), ((void **)(&__pyx_v_mats))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 306, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_tmp = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/ST.pyx":307
 *         cdef Py_ssize_t k=0, n = len(operators)
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscMat),<void**>&mats)
 *         for k from 0 <= k < n: mats[k] = (<Mat?>operators[k]).mat             # <<<<<<<<<<<<<<
 *         CHKERR( STSetMatrices(self.st, <PetscInt>n, mats) )
 * 
 */
  __pyx_t_2 = __pyx_v_n;
  for (__pyx_v_k = 0; __pyx_v_k < __pyx_t_2; __pyx_v_k++) {
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_operators, __pyx_v_k, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 307, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_8petsc4py_5PETSc_Mat)))) __PYX_ERR(0, 307, __pyx_L1_error)
    __pyx_t_3 = ((struct PyPetscMatObject *)__pyx_t_1)->mat;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    (__pyx_v_mats[__pyx_v_k]) = __pyx_t_3;
  }

  /* "SLEPc/ST.pyx":308
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscMat),<void**>&mats)
 *         for k from 0 <= k < n: mats[k] = (<Mat?>operators[k]).mat
 *         CHKERR( STSetMatrices(self.st, <PetscInt>n, mats) )             # <<<<<<<<<<<<<<
 * 
 *     def getMatrices(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STSetMatrices(__pyx_v_self->st, ((PetscInt)__pyx_v_n), __pyx_v_mats)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 308, __pyx_L1_error)

  /* "SLEPc/ST.pyx":294
 *         return val
 * 
 *     def setMatrices(self, operators):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the matrices associated with the eigenvalue problem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setMatrices", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XDECREF(__pyx_v_operators);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":310
 *         CHKERR( STSetMatrices(self.st, <PetscInt>n, mats) )
 * 
 *     def getMatrices(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the matrices associated with the eigenvalue problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_35getMatrices(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_34getMatrices[] = "ST.getMatrices(self)\n\n        Gets the matrices associated with the eigenvalue problem.\n\n        Returns\n        -------\n        operators: tuple of Mat\n           The matrices associated with the eigensystem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_35getMatrices(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getMatrices (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getMatrices", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getMatrices", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_34getMatrices(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_34getMatrices(struct PySlepcSTObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  Mat __pyx_v_mat;
  PetscInt __pyx_v_k;
  PetscInt __pyx_v_n;
  PyObject *__pyx_v_operators = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getMatrices", 0);

  /* "SLEPc/ST.pyx":320
 *         """
 *         cdef Mat A
 *         cdef PetscMat mat = NULL             # <<<<<<<<<<<<<<
 *         cdef PetscInt k=0, n=0
 *         CHKERR( STGetNumMatrices(self.st, &n) )
 */
  __pyx_v_mat = NULL;

  /* "SLEPc/ST.pyx":321
 *         cdef Mat A
 *         cdef PetscMat mat = NULL
 *         cdef PetscInt k=0, n=0             # <<<<<<<<<<<<<<
 *         CHKERR( STGetNumMatrices(self.st, &n) )
 *         cdef object operators = []
 */
  __pyx_v_k = 0;
  __pyx_v_n = 0;

  /* "SLEPc/ST.pyx":322
 *         cdef PetscMat mat = NULL
 *         cdef PetscInt k=0, n=0
 *         CHKERR( STGetNumMatrices(self.st, &n) )             # <<<<<<<<<<<<<<
 *         cdef object operators = []
 *         for k from 0 <= k < n:
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STGetNumMatrices(__pyx_v_self->st, (&__pyx_v_n))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 322, __pyx_L1_error)

  /* "SLEPc/ST.pyx":323
 *         cdef PetscInt k=0, n=0
 *         CHKERR( STGetNumMatrices(self.st, &n) )
 *         cdef object operators = []             # <<<<<<<<<<<<<<
 *         for k from 0 <= k < n:
 *             CHKERR( STGetMatrix(self.st, k, &mat) )
 */
  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 323, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_operators = __pyx_t_2;
  __pyx_t_2 = 0;

  /* "SLEPc/ST.pyx":324
 *         CHKERR( STGetNumMatrices(self.st, &n) )
 *         cdef object operators = []
 *         for k from 0 <= k < n:             # <<<<<<<<<<<<<<
 *             CHKERR( STGetMatrix(self.st, k, &mat) )
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)
 */
  __pyx_t_3 = __pyx_v_n;
  for (__pyx_v_k = 0; __pyx_v_k < __pyx_t_3; __pyx_v_k++) {

    /* "SLEPc/ST.pyx":325
 *         cdef object operators = []
 *         for k from 0 <= k < n:
 *             CHKERR( STGetMatrix(self.st, k, &mat) )             # <<<<<<<<<<<<<<
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)
 *             operators.append(A)
 */
    __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STGetMatrix(__pyx_v_self->st, __pyx_v_k, (&__pyx_v_mat))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 325, __pyx_L1_error)

    /* "SLEPc/ST.pyx":326
 *         for k from 0 <= k < n:
 *             CHKERR( STGetMatrix(self.st, k, &mat) )
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)             # <<<<<<<<<<<<<<
 *             operators.append(A)
 *         return tuple(operators)
 */
    __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 326, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_A, ((struct PyPetscMatObject *)__pyx_t_2));
    __pyx_t_2 = 0;
    __pyx_v_A->mat = __pyx_v_mat;
    (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_A->__pyx_base.obj));

    /* "SLEPc/ST.pyx":327
 *             CHKERR( STGetMatrix(self.st, k, &mat) )
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)
 *             operators.append(A)             # <<<<<<<<<<<<<<
 *         return tuple(operators)
 * 
 */
    __pyx_t_4 = __Pyx_PyObject_Append(__pyx_v_operators, ((PyObject *)__pyx_v_A)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 327, __pyx_L1_error)
  }

  /* "SLEPc/ST.pyx":328
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)
 *             operators.append(A)
 *         return tuple(operators)             # <<<<<<<<<<<<<<
 * 
 *     def setMatStructure(self, structure):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_v_operators); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 328, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":310
 *         CHKERR( STSetMatrices(self.st, <PetscInt>n, mats) )
 * 
 *     def getMatrices(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the matrices associated with the eigenvalue problem.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.getMatrices", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_A);
  __Pyx_XDECREF(__pyx_v_operators);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":330
 *         return tuple(operators)
 * 
 *     def setMatStructure(self, structure):             # <<<<<<<<<<<<<<
 *         """
 *         Sets an internal Mat.Structure attribute to indicate which is
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_37setMatStructure(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_36setMatStructure[] = "ST.setMatStructure(self, structure)\n\n        Sets an internal Mat.Structure attribute to indicate which is\n        the relation of the sparsity pattern of the two matrices ``A``\n        and ``B`` constituting the generalized eigenvalue\n        problem. This function has no effect in the case of standard\n        eigenproblems.\n\n        Parameters\n        ----------\n        structure: `PETSc.Mat.Structure` enumerate\n                   Either same, different, or a subset of the non-zero\n                   sparsity pattern.\n\n        Notes\n        -----\n        By default, the sparsity patterns are assumed to be\n        different. If the patterns are equal or a subset then it is\n        recommended to set this attribute for efficiency reasons (in\n        particular, for internal *AXPY()* matrix operations).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_37setMatStructure(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_structure = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setMatStructure (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_structure,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_structure)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setMatStructure") < 0)) __PYX_ERR(0, 330, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_structure = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setMatStructure", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 330, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setMatStructure", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_36setMatStructure(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_structure);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_36setMatStructure(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_structure) {
  MatStructure __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  MatStructure __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setMatStructure", 0);

  /* "SLEPc/ST.pyx":351
 *         particular, for internal *AXPY()* matrix operations).
 *         """
 *         cdef PetscMatStructure val = matstructure(structure)             # <<<<<<<<<<<<<<
 *         CHKERR( STSetMatStructure(self.st, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_matstructure(__pyx_v_structure); if (unlikely(__pyx_t_1 == ((MatStructure)((MatStructure)-1L)))) __PYX_ERR(0, 351, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/ST.pyx":352
 *         """
 *         cdef PetscMatStructure val = matstructure(structure)
 *         CHKERR( STSetMatStructure(self.st, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getMatStructure(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STSetMatStructure(__pyx_v_self->st, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 352, __pyx_L1_error)

  /* "SLEPc/ST.pyx":330
 *         return tuple(operators)
 * 
 *     def setMatStructure(self, structure):             # <<<<<<<<<<<<<<
 *         """
 *         Sets an internal Mat.Structure attribute to indicate which is
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setMatStructure", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":354
 *         CHKERR( STSetMatStructure(self.st, val) )
 * 
 *     def getMatStructure(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the internal Mat.Structure attribute to indicate which is
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_39getMatStructure(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_38getMatStructure[] = "ST.getMatStructure(self)\n\n        Gets the internal Mat.Structure attribute to indicate which is\n        the relation of the sparsity pattern of the matrices.\n\n        Returns\n        -------\n        structure: `PETSc.Mat.Structure` enumerate\n                   The structure flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_39getMatStructure(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getMatStructure (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getMatStructure", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getMatStructure", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_38getMatStructure(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_38getMatStructure(struct PySlepcSTObject *__pyx_v_self) {
  MatStructure __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getMatStructure", 0);

  /* "SLEPc/ST.pyx":365
 *         """
 *         cdef PetscMatStructure val
 *         CHKERR( STGetMatStructure(self.st, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STGetMatStructure(__pyx_v_self->st, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 365, __pyx_L1_error)

  /* "SLEPc/ST.pyx":366
 *         cdef PetscMatStructure val
 *         CHKERR( STGetMatStructure(self.st, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setKSP(self, KSP ksp):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_MatStructure(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 366, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":354
 *         CHKERR( STSetMatStructure(self.st, val) )
 * 
 *     def getMatStructure(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the internal Mat.Structure attribute to indicate which is
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.getMatStructure", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":368
 *         return val
 * 
 *     def setKSP(self, KSP ksp):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the KSP object associated with the spectral
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_41setKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_40setKSP[] = "ST.setKSP(self, KSP ksp)\n\n        Sets the KSP object associated with the spectral\n        transformation.\n\n        Parameters\n        ----------\n        ksp: KSP\n             The linear solver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_41setKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscKSPObject *__pyx_v_ksp = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setKSP (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ksp,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ksp)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setKSP") < 0)) __PYX_ERR(0, 368, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_ksp = ((struct PyPetscKSPObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setKSP", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 368, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ksp), __pyx_ptype_8petsc4py_5PETSc_KSP, 0, "ksp", 0))) __PYX_ERR(0, 368, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_40setKSP(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_ksp);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_40setKSP(struct PySlepcSTObject *__pyx_v_self, struct PyPetscKSPObject *__pyx_v_ksp) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setKSP", 0);

  /* "SLEPc/ST.pyx":378
 *              The linear solver object.
 *         """
 *         CHKERR( STSetKSP(self.st, ksp.ksp) )             # <<<<<<<<<<<<<<
 * 
 *     def getKSP(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STSetKSP(__pyx_v_self->st, __pyx_v_ksp->ksp)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 378, __pyx_L1_error)

  /* "SLEPc/ST.pyx":368
 *         return val
 * 
 *     def setKSP(self, KSP ksp):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the KSP object associated with the spectral
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":380
 *         CHKERR( STSetKSP(self.st, ksp.ksp) )
 * 
 *     def getKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the KSP object associated with the spectral
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_43getKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_42getKSP[] = "ST.getKSP(self)\n\n        Gets the KSP object associated with the spectral\n        transformation.\n\n        Returns\n        -------\n        ksp: KSP\n             The linear solver object.\n\n        Notes\n        -----\n        On output, the internal value of KSP can be ``NULL`` if the\n        combination of eigenproblem type and selected transformation\n        does not require to solve a linear system of equations.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_43getKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getKSP (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getKSP", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getKSP", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_42getKSP(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_42getKSP(struct PySlepcSTObject *__pyx_v_self) {
  struct PyPetscKSPObject *__pyx_v_ksp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getKSP", 0);

  /* "SLEPc/ST.pyx":396
 *         does not require to solve a linear system of equations.
 *         """
 *         cdef KSP ksp = KSP()             # <<<<<<<<<<<<<<
 *         CHKERR( STGetKSP(self.st, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_KSP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 396, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ksp = ((struct PyPetscKSPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/ST.pyx":397
 *         """
 *         cdef KSP ksp = KSP()
 *         CHKERR( STGetKSP(self.st, &ksp.ksp) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(ksp.obj)
 *         return ksp
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STGetKSP(__pyx_v_self->st, (&__pyx_v_ksp->ksp))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 397, __pyx_L1_error)

  /* "SLEPc/ST.pyx":398
 *         cdef KSP ksp = KSP()
 *         CHKERR( STGetKSP(self.st, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)             # <<<<<<<<<<<<<<
 *         return ksp
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ksp->__pyx_base.obj));

  /* "SLEPc/ST.pyx":399
 *         CHKERR( STGetKSP(self.st, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 *         return ksp             # <<<<<<<<<<<<<<
 * 
 *     def setPreconditionerMat(self, Mat P=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ksp));
  __pyx_r = ((PyObject *)__pyx_v_ksp);
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":380
 *         CHKERR( STSetKSP(self.st, ksp.ksp) )
 * 
 *     def getKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the KSP object associated with the spectral
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.getKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ksp);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":401
 *         return ksp
 * 
 *     def setPreconditionerMat(self, Mat P=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the matrix to be used to build the preconditioner.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_45setPreconditionerMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_44setPreconditionerMat[] = "ST.setPreconditionerMat(self, Mat P=None)\n\n        Sets the matrix to be used to build the preconditioner.\n\n        Parameters\n        ----------\n        P: Mat, optional\n           The matrix that will be used in constructing the preconditioner.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_45setPreconditionerMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_P = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setPreconditionerMat (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_P,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscMatObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_P);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setPreconditionerMat") < 0)) __PYX_ERR(0, 401, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_P = ((struct PyPetscMatObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setPreconditionerMat", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 401, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setPreconditionerMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_P), __pyx_ptype_8petsc4py_5PETSc_Mat, 1, "P", 0))) __PYX_ERR(0, 401, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_44setPreconditionerMat(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_P);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_44setPreconditionerMat(struct PySlepcSTObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_P) {
  Mat __pyx_v_Pmat;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Mat __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setPreconditionerMat", 0);

  /* "SLEPc/ST.pyx":410
 *            The matrix that will be used in constructing the preconditioner.
 *         """
 *         cdef PetscMat Pmat = P.mat if P is not None else <PetscMat>NULL             # <<<<<<<<<<<<<<
 *         CHKERR( STSetPreconditionerMat(self.st, Pmat) )
 * 
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_P) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_P->mat;
  } else {
    __pyx_t_1 = ((Mat)NULL);
  }
  __pyx_v_Pmat = __pyx_t_1;

  /* "SLEPc/ST.pyx":411
 *         """
 *         cdef PetscMat Pmat = P.mat if P is not None else <PetscMat>NULL
 *         CHKERR( STSetPreconditionerMat(self.st, Pmat) )             # <<<<<<<<<<<<<<
 * 
 *     def getPreconditionerMat(self):
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STSetPreconditionerMat(__pyx_v_self->st, __pyx_v_Pmat)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 411, __pyx_L1_error)

  /* "SLEPc/ST.pyx":401
 *         return ksp
 * 
 *     def setPreconditionerMat(self, Mat P=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the matrix to be used to build the preconditioner.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setPreconditionerMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":413
 *         CHKERR( STSetPreconditionerMat(self.st, Pmat) )
 * 
 *     def getPreconditionerMat(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the matrix previously set by setPreconditionerMat().
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_47getPreconditionerMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_46getPreconditionerMat[] = "ST.getPreconditionerMat(self)\n\n        Gets the matrix previously set by setPreconditionerMat().\n\n        Returns\n        -------\n        P: Mat\n           The matrix that will be used in constructing the preconditioner.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_47getPreconditionerMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getPreconditionerMat (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getPreconditionerMat", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getPreconditionerMat", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_46getPreconditionerMat(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_46getPreconditionerMat(struct PySlepcSTObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_P = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getPreconditionerMat", 0);

  /* "SLEPc/ST.pyx":422
 *            The matrix that will be used in constructing the preconditioner.
 *         """
 *         cdef Mat P = Mat()             # <<<<<<<<<<<<<<
 *         CHKERR( STGetPreconditionerMat(self.st, &P.mat) )
 *         PetscINCREF(P.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 422, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_P = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/ST.pyx":423
 *         """
 *         cdef Mat P = Mat()
 *         CHKERR( STGetPreconditionerMat(self.st, &P.mat) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(P.obj)
 *         return P
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STGetPreconditionerMat(__pyx_v_self->st, (&__pyx_v_P->mat))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 423, __pyx_L1_error)

  /* "SLEPc/ST.pyx":424
 *         cdef Mat P = Mat()
 *         CHKERR( STGetPreconditionerMat(self.st, &P.mat) )
 *         PetscINCREF(P.obj)             # <<<<<<<<<<<<<<
 *         return P
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_P->__pyx_base.obj));

  /* "SLEPc/ST.pyx":425
 *         CHKERR( STGetPreconditionerMat(self.st, &P.mat) )
 *         PetscINCREF(P.obj)
 *         return P             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_P));
  __pyx_r = ((PyObject *)__pyx_v_P);
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":413
 *         CHKERR( STSetPreconditionerMat(self.st, Pmat) )
 * 
 *     def getPreconditionerMat(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the matrix previously set by setPreconditionerMat().
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.getPreconditionerMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_P);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":429
 *     #
 * 
 *     def setUp(self):             # <<<<<<<<<<<<<<
 *         """
 *         Prepares for the use of a spectral transformation.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_49setUp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_48setUp[] = "ST.setUp(self)\n\n        Prepares for the use of a spectral transformation.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_49setUp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setUp (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setUp", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setUp", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_48setUp(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_48setUp(struct PySlepcSTObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setUp", 0);

  /* "SLEPc/ST.pyx":433
 *         Prepares for the use of a spectral transformation.
 *         """
 *         CHKERR( STSetUp(self.st) )             # <<<<<<<<<<<<<<
 * 
 *     def apply(self, Vec x, Vec y):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STSetUp(__pyx_v_self->st)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 433, __pyx_L1_error)

  /* "SLEPc/ST.pyx":429
 *     #
 * 
 *     def setUp(self):             # <<<<<<<<<<<<<<
 *         """
 *         Prepares for the use of a spectral transformation.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setUp", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":435
 *         CHKERR( STSetUp(self.st) )
 * 
 *     def apply(self, Vec x, Vec y):             # <<<<<<<<<<<<<<
 *         """
 *         Applies the spectral transformation operator to a vector, for
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_51apply(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_50apply[] = "ST.apply(self, Vec x, Vec y)\n\n        Applies the spectral transformation operator to a vector, for\n        instance ``(A - sB)^-1 B`` in the case of the shift-and-invert\n        transformation and generalized eigenproblem.\n\n        Parameters\n        ----------\n        x: Vec\n           The input vector.\n        y: Vec\n           The result vector.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_51apply(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscVecObject *__pyx_v_x = 0;
  struct PyPetscVecObject *__pyx_v_y = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("apply (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("apply", 1, 2, 2, 1); __PYX_ERR(0, 435, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "apply") < 0)) __PYX_ERR(0, 435, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_x = ((struct PyPetscVecObject *)values[0]);
    __pyx_v_y = ((struct PyPetscVecObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("apply", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 435, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.apply", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_x), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "x", 0))) __PYX_ERR(0, 435, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "y", 0))) __PYX_ERR(0, 435, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_50apply(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_x, __pyx_v_y);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_50apply(struct PySlepcSTObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_x, struct PyPetscVecObject *__pyx_v_y) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("apply", 0);

  /* "SLEPc/ST.pyx":448
 *            The result vector.
 *         """
 *         CHKERR( STApply(self.st, x.vec, y.vec) )             # <<<<<<<<<<<<<<
 * 
 *     def applyTranspose(self, Vec x, Vec y):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STApply(__pyx_v_self->st, __pyx_v_x->vec, __pyx_v_y->vec)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 448, __pyx_L1_error)

  /* "SLEPc/ST.pyx":435
 *         CHKERR( STSetUp(self.st) )
 * 
 *     def apply(self, Vec x, Vec y):             # <<<<<<<<<<<<<<
 *         """
 *         Applies the spectral transformation operator to a vector, for
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.apply", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":450
 *         CHKERR( STApply(self.st, x.vec, y.vec) )
 * 
 *     def applyTranspose(self, Vec x, Vec y):             # <<<<<<<<<<<<<<
 *         """
 *         Applies the transpose of the operator to a vector, for
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_53applyTranspose(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_52applyTranspose[] = "ST.applyTranspose(self, Vec x, Vec y)\n\n        Applies the transpose of the operator to a vector, for\n        instance ``B^T(A - sB)^-T`` in the case of the\n        shift-and-invert transformation and generalized eigenproblem.\n\n        Parameters\n        ----------\n        x: Vec\n           The input vector.\n        y: Vec\n           The result vector.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_53applyTranspose(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscVecObject *__pyx_v_x = 0;
  struct PyPetscVecObject *__pyx_v_y = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("applyTranspose (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("applyTranspose", 1, 2, 2, 1); __PYX_ERR(0, 450, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "applyTranspose") < 0)) __PYX_ERR(0, 450, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_x = ((struct PyPetscVecObject *)values[0]);
    __pyx_v_y = ((struct PyPetscVecObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("applyTranspose", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 450, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.applyTranspose", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_x), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "x", 0))) __PYX_ERR(0, 450, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "y", 0))) __PYX_ERR(0, 450, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_52applyTranspose(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_x, __pyx_v_y);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_52applyTranspose(struct PySlepcSTObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_x, struct PyPetscVecObject *__pyx_v_y) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("applyTranspose", 0);

  /* "SLEPc/ST.pyx":463
 *            The result vector.
 *         """
 *         CHKERR( STApplyTranspose(self.st, x.vec, y.vec) )             # <<<<<<<<<<<<<<
 * 
 *     def applyHermitianTranspose(self, Vec x, Vec y):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STApplyTranspose(__pyx_v_self->st, __pyx_v_x->vec, __pyx_v_y->vec)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 463, __pyx_L1_error)

  /* "SLEPc/ST.pyx":450
 *         CHKERR( STApply(self.st, x.vec, y.vec) )
 * 
 *     def applyTranspose(self, Vec x, Vec y):             # <<<<<<<<<<<<<<
 *         """
 *         Applies the transpose of the operator to a vector, for
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.applyTranspose", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":465
 *         CHKERR( STApplyTranspose(self.st, x.vec, y.vec) )
 * 
 *     def applyHermitianTranspose(self, Vec x, Vec y):             # <<<<<<<<<<<<<<
 *         """
 *         Applies the hermitian-transpose of the operator to a vector, for
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_55applyHermitianTranspose(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_54applyHermitianTranspose[] = "ST.applyHermitianTranspose(self, Vec x, Vec y)\n\n        Applies the hermitian-transpose of the operator to a vector, for\n        instance ``B^H(A - sB)^-H`` in the case of the\n        shift-and-invert transformation and generalized eigenproblem.\n\n        Parameters\n        ----------\n        x: Vec\n           The input vector.\n        y: Vec\n           The result vector.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_55applyHermitianTranspose(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscVecObject *__pyx_v_x = 0;
  struct PyPetscVecObject *__pyx_v_y = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("applyHermitianTranspose (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("applyHermitianTranspose", 1, 2, 2, 1); __PYX_ERR(0, 465, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "applyHermitianTranspose") < 0)) __PYX_ERR(0, 465, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_x = ((struct PyPetscVecObject *)values[0]);
    __pyx_v_y = ((struct PyPetscVecObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("applyHermitianTranspose", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 465, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.applyHermitianTranspose", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_x), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "x", 0))) __PYX_ERR(0, 465, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "y", 0))) __PYX_ERR(0, 465, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_54applyHermitianTranspose(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_x, __pyx_v_y);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_54applyHermitianTranspose(struct PySlepcSTObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_x, struct PyPetscVecObject *__pyx_v_y) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("applyHermitianTranspose", 0);

  /* "SLEPc/ST.pyx":478
 *            The result vector.
 *         """
 *         CHKERR( STApplyHermitianTranspose(self.st, x.vec, y.vec) )             # <<<<<<<<<<<<<<
 * 
 *     def applyMat(self, Mat x, Mat y):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STApplyHermitianTranspose(__pyx_v_self->st, __pyx_v_x->vec, __pyx_v_y->vec)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 478, __pyx_L1_error)

  /* "SLEPc/ST.pyx":465
 *         CHKERR( STApplyTranspose(self.st, x.vec, y.vec) )
 * 
 *     def applyHermitianTranspose(self, Vec x, Vec y):             # <<<<<<<<<<<<<<
 *         """
 *         Applies the hermitian-transpose of the operator to a vector, for
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.applyHermitianTranspose", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":480
 *         CHKERR( STApplyHermitianTranspose(self.st, x.vec, y.vec) )
 * 
 *     def applyMat(self, Mat x, Mat y):             # <<<<<<<<<<<<<<
 *         """
 *         Applies the spectral transformation operator to a matrix, for
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_57applyMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_56applyMat[] = "ST.applyMat(self, Mat x, Mat y)\n\n        Applies the spectral transformation operator to a matrix, for\n        instance ``(A - sB)^-1 B`` in the case of the shift-and-invert\n        transformation and generalized eigenproblem.\n\n        Parameters\n        ----------\n        x: Mat\n           The input matrix.\n        y: Mat\n           The result matrix.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_57applyMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_x = 0;
  struct PyPetscMatObject *__pyx_v_y = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("applyMat (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("applyMat", 1, 2, 2, 1); __PYX_ERR(0, 480, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "applyMat") < 0)) __PYX_ERR(0, 480, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_x = ((struct PyPetscMatObject *)values[0]);
    __pyx_v_y = ((struct PyPetscMatObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("applyMat", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 480, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.applyMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_x), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "x", 0))) __PYX_ERR(0, 480, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "y", 0))) __PYX_ERR(0, 480, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_56applyMat(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_x, __pyx_v_y);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_56applyMat(struct PySlepcSTObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_x, struct PyPetscMatObject *__pyx_v_y) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("applyMat", 0);

  /* "SLEPc/ST.pyx":493
 *            The result matrix.
 *         """
 *         CHKERR( STApplyMat(self.st, x.mat, y.mat) )             # <<<<<<<<<<<<<<
 * 
 *     def getOperator(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STApplyMat(__pyx_v_self->st, __pyx_v_x->mat, __pyx_v_y->mat)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 493, __pyx_L1_error)

  /* "SLEPc/ST.pyx":480
 *         CHKERR( STApplyHermitianTranspose(self.st, x.vec, y.vec) )
 * 
 *     def applyMat(self, Mat x, Mat y):             # <<<<<<<<<<<<<<
 *         """
 *         Applies the spectral transformation operator to a matrix, for
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.applyMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":495
 *         CHKERR( STApplyMat(self.st, x.mat, y.mat) )
 * 
 *     def getOperator(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns a shell matrix that represents the operator of the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_59getOperator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_58getOperator[] = "ST.getOperator(self)\n\n        Returns a shell matrix that represents the operator of the\n        spectral transformation.\n\n        Returns\n        -------\n        op: Mat\n            Operator matrix.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_59getOperator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOperator (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOperator", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOperator", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_58getOperator(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_58getOperator(struct PySlepcSTObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_op = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOperator", 0);

  /* "SLEPc/ST.pyx":505
 *             Operator matrix.
 *         """
 *         cdef Mat op = Mat()             # <<<<<<<<<<<<<<
 *         CHKERR( STGetOperator(self.st, &op.mat) )
 *         PetscINCREF(op.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 505, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_op = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/ST.pyx":506
 *         """
 *         cdef Mat op = Mat()
 *         CHKERR( STGetOperator(self.st, &op.mat) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(op.obj)
 *         return op
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STGetOperator(__pyx_v_self->st, (&__pyx_v_op->mat))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 506, __pyx_L1_error)

  /* "SLEPc/ST.pyx":507
 *         cdef Mat op = Mat()
 *         CHKERR( STGetOperator(self.st, &op.mat) )
 *         PetscINCREF(op.obj)             # <<<<<<<<<<<<<<
 *         return op
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_op->__pyx_base.obj));

  /* "SLEPc/ST.pyx":508
 *         CHKERR( STGetOperator(self.st, &op.mat) )
 *         PetscINCREF(op.obj)
 *         return op             # <<<<<<<<<<<<<<
 * 
 *     def restoreOperator(self, Mat op):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_op));
  __pyx_r = ((PyObject *)__pyx_v_op);
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":495
 *         CHKERR( STApplyMat(self.st, x.mat, y.mat) )
 * 
 *     def getOperator(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns a shell matrix that represents the operator of the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.getOperator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_op);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":510
 *         return op
 * 
 *     def restoreOperator(self, Mat op):             # <<<<<<<<<<<<<<
 *         """
 *         Restore the previously seized operator matrix.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_61restoreOperator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_60restoreOperator[] = "ST.restoreOperator(self, Mat op)\n\n        Restore the previously seized operator matrix.\n\n        Parameters\n        ----------\n        op: Mat\n            Operator matrix previously obtained with getOperator().\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_61restoreOperator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_op = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("restoreOperator (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_op,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_op)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "restoreOperator") < 0)) __PYX_ERR(0, 510, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_op = ((struct PyPetscMatObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("restoreOperator", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 510, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.restoreOperator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_op), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "op", 0))) __PYX_ERR(0, 510, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_60restoreOperator(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_op);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_60restoreOperator(struct PySlepcSTObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_op) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("restoreOperator", 0);

  /* "SLEPc/ST.pyx":519
 *             Operator matrix previously obtained with getOperator().
 *         """
 *         CHKERR( PetscObjectDereference(<PetscObject>op.mat) )             # <<<<<<<<<<<<<<
 *         CHKERR( STRestoreOperator(self.st, &op.mat) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscObjectDereference(((PetscObject)__pyx_v_op->mat))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 519, __pyx_L1_error)

  /* "SLEPc/ST.pyx":520
 *         """
 *         CHKERR( PetscObjectDereference(<PetscObject>op.mat) )
 *         CHKERR( STRestoreOperator(self.st, &op.mat) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STRestoreOperator(__pyx_v_self->st, (&__pyx_v_op->mat))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 520, __pyx_L1_error)

  /* "SLEPc/ST.pyx":510
 *         return op
 * 
 *     def restoreOperator(self, Mat op):             # <<<<<<<<<<<<<<
 *         """
 *         Restore the previously seized operator matrix.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.restoreOperator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":524
 *     #
 * 
 *     def setCayleyAntishift(self, tau):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the value of the anti-shift for the Cayley spectral
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_63setCayleyAntishift(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_62setCayleyAntishift[] = "ST.setCayleyAntishift(self, tau)\n\n        Sets the value of the anti-shift for the Cayley spectral\n        transformation.\n\n        Parameters\n        ----------\n        tau: scalar (possibly complex)\n             The anti-shift.\n\n        Notes\n        -----\n        In the generalized Cayley transform, the operator can be\n        expressed as ``OP = inv(A - sigma B)*(A + tau B)``. This\n        function sets the value of `tau`.  Use `setShift()` for\n        setting ``sigma``.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_63setCayleyAntishift(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_tau = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCayleyAntishift (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_tau,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tau)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCayleyAntishift") < 0)) __PYX_ERR(0, 524, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_tau = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCayleyAntishift", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 524, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setCayleyAntishift", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_62setCayleyAntishift(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_tau);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_62setCayleyAntishift(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_tau) {
  PetscScalar __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCayleyAntishift", 0);

  /* "SLEPc/ST.pyx":541
 *         setting ``sigma``.
 *         """
 *         cdef PetscScalar sval = asScalar(tau)             # <<<<<<<<<<<<<<
 *         CHKERR( STCayleySetAntishift(self.st, sval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_tau); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(0, 541, __pyx_L1_error)
  __pyx_v_sval = __pyx_t_1;

  /* "SLEPc/ST.pyx":542
 *         """
 *         cdef PetscScalar sval = asScalar(tau)
 *         CHKERR( STCayleySetAntishift(self.st, sval) )             # <<<<<<<<<<<<<<
 * 
 *     def getCayleyAntishift(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STCayleySetAntishift(__pyx_v_self->st, __pyx_v_sval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 542, __pyx_L1_error)

  /* "SLEPc/ST.pyx":524
 *     #
 * 
 *     def setCayleyAntishift(self, tau):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the value of the anti-shift for the Cayley spectral
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setCayleyAntishift", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":544
 *         CHKERR( STCayleySetAntishift(self.st, sval) )
 * 
 *     def getCayleyAntishift(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the value of the anti-shift for the Cayley spectral
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_65getCayleyAntishift(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_64getCayleyAntishift[] = "ST.getCayleyAntishift(self)\n\n        Gets the value of the anti-shift for the Cayley spectral\n        transformation.\n\n        Returns\n        -------\n        tau: scalar (possibly complex)\n             The anti-shift.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_65getCayleyAntishift(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCayleyAntishift (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCayleyAntishift", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCayleyAntishift", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_64getCayleyAntishift(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_64getCayleyAntishift(struct PySlepcSTObject *__pyx_v_self) {
  PetscScalar __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCayleyAntishift", 0);

  /* "SLEPc/ST.pyx":554
 *              The anti-shift.
 *         """
 *         cdef PetscScalar sval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( STCayleyGetAntishift(self.st, &sval) )
 *         return toScalar(sval)
 */
  __pyx_v_sval = 0.0;

  /* "SLEPc/ST.pyx":555
 *         """
 *         cdef PetscScalar sval = 0
 *         CHKERR( STCayleyGetAntishift(self.st, &sval) )             # <<<<<<<<<<<<<<
 *         return toScalar(sval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STCayleyGetAntishift(__pyx_v_self->st, (&__pyx_v_sval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 555, __pyx_L1_error)

  /* "SLEPc/ST.pyx":556
 *         cdef PetscScalar sval = 0
 *         CHKERR( STCayleyGetAntishift(self.st, &sval) )
 *         return toScalar(sval)             # <<<<<<<<<<<<<<
 * 
 *     def setFilterInterval(self, inta, intb):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_sval); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 556, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":544
 *         CHKERR( STCayleySetAntishift(self.st, sval) )
 * 
 *     def getCayleyAntishift(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the value of the anti-shift for the Cayley spectral
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.getCayleyAntishift", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":558
 *         return toScalar(sval)
 * 
 *     def setFilterInterval(self, inta, intb):             # <<<<<<<<<<<<<<
 *         """
 *         Defines the interval containing the desired eigenvalues.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_67setFilterInterval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_66setFilterInterval[] = "ST.setFilterInterval(self, inta, intb)\n\n        Defines the interval containing the desired eigenvalues.\n\n        Parameters\n        ----------\n        inta: float\n              The left end of the interval.\n        intb: float\n              The right end of the interval.\n\n        Notes\n        -----\n        The filter will be configured to emphasize eigenvalues contained\n        in the given interval, and damp out eigenvalues outside it. If the\n        interval is open, then the filter is low- or high-pass, otherwise\n        it is mid-pass.\n\n        Common usage is to set the interval in `EPS` with `EPS.setInterval()`.\n\n        The interval must be contained within the numerical range of the\n        matrix, see `ST.setFilterRange()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_67setFilterInterval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_inta = 0;
  PyObject *__pyx_v_intb = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFilterInterval (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inta,&__pyx_n_s_intb,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_inta)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_intb)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setFilterInterval", 1, 2, 2, 1); __PYX_ERR(0, 558, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setFilterInterval") < 0)) __PYX_ERR(0, 558, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_inta = values[0];
    __pyx_v_intb = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setFilterInterval", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 558, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setFilterInterval", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_66setFilterInterval(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_inta, __pyx_v_intb);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_66setFilterInterval(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_inta, PyObject *__pyx_v_intb) {
  PetscReal __pyx_v_rval1;
  PetscReal __pyx_v_rval2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFilterInterval", 0);

  /* "SLEPc/ST.pyx":581
 *         matrix, see `ST.setFilterRange()`.
 *         """
 *         cdef PetscReal rval1 = asReal(inta)             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval2 = asReal(intb)
 *         CHKERR( STFilterSetInterval(self.st, rval1, rval2) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_inta); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(0, 581, __pyx_L1_error)
  __pyx_v_rval1 = __pyx_t_1;

  /* "SLEPc/ST.pyx":582
 *         """
 *         cdef PetscReal rval1 = asReal(inta)
 *         cdef PetscReal rval2 = asReal(intb)             # <<<<<<<<<<<<<<
 *         CHKERR( STFilterSetInterval(self.st, rval1, rval2) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_intb); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(0, 582, __pyx_L1_error)
  __pyx_v_rval2 = __pyx_t_1;

  /* "SLEPc/ST.pyx":583
 *         cdef PetscReal rval1 = asReal(inta)
 *         cdef PetscReal rval2 = asReal(intb)
 *         CHKERR( STFilterSetInterval(self.st, rval1, rval2) )             # <<<<<<<<<<<<<<
 * 
 *     def getFilterInterval(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STFilterSetInterval(__pyx_v_self->st, __pyx_v_rval1, __pyx_v_rval2)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 583, __pyx_L1_error)

  /* "SLEPc/ST.pyx":558
 *         return toScalar(sval)
 * 
 *     def setFilterInterval(self, inta, intb):             # <<<<<<<<<<<<<<
 *         """
 *         Defines the interval containing the desired eigenvalues.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setFilterInterval", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":585
 *         CHKERR( STFilterSetInterval(self.st, rval1, rval2) )
 * 
 *     def getFilterInterval(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the interval containing the desired eigenvalues.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_69getFilterInterval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_68getFilterInterval[] = "ST.getFilterInterval(self)\n\n        Gets the interval containing the desired eigenvalues.\n\n        Returns\n        -------\n        inta: float\n              The left end of the interval.\n        intb: float\n              The right end of the interval.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_69getFilterInterval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getFilterInterval (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getFilterInterval", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getFilterInterval", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_68getFilterInterval(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_68getFilterInterval(struct PySlepcSTObject *__pyx_v_self) {
  PetscReal __pyx_v_inta;
  PetscReal __pyx_v_intb;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getFilterInterval", 0);

  /* "SLEPc/ST.pyx":596
 *               The right end of the interval.
 *         """
 *         cdef PetscReal inta = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal intb = 0
 *         CHKERR( STFilterGetInterval(self.st, &inta, &intb) )
 */
  __pyx_v_inta = 0.0;

  /* "SLEPc/ST.pyx":597
 *         """
 *         cdef PetscReal inta = 0
 *         cdef PetscReal intb = 0             # <<<<<<<<<<<<<<
 *         CHKERR( STFilterGetInterval(self.st, &inta, &intb) )
 *         return (toReal(inta), toReal(intb))
 */
  __pyx_v_intb = 0.0;

  /* "SLEPc/ST.pyx":598
 *         cdef PetscReal inta = 0
 *         cdef PetscReal intb = 0
 *         CHKERR( STFilterGetInterval(self.st, &inta, &intb) )             # <<<<<<<<<<<<<<
 *         return (toReal(inta), toReal(intb))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STFilterGetInterval(__pyx_v_self->st, (&__pyx_v_inta), (&__pyx_v_intb))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 598, __pyx_L1_error)

  /* "SLEPc/ST.pyx":599
 *         cdef PetscReal intb = 0
 *         CHKERR( STFilterGetInterval(self.st, &inta, &intb) )
 *         return (toReal(inta), toReal(intb))             # <<<<<<<<<<<<<<
 * 
 *     def setFilterRange(self, left, right):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_inta); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 599, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_intb); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 599, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 599, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":585
 *         CHKERR( STFilterSetInterval(self.st, rval1, rval2) )
 * 
 *     def getFilterInterval(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the interval containing the desired eigenvalues.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.getFilterInterval", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":601
 *         return (toReal(inta), toReal(intb))
 * 
 *     def setFilterRange(self, left, right):             # <<<<<<<<<<<<<<
 *         """
 *         Defines the numerical range (or field of values) of the matrix, that is,
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_71setFilterRange(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_70setFilterRange[] = "ST.setFilterRange(self, left, right)\n\n        Defines the numerical range (or field of values) of the matrix, that is,\n        the interval containing all eigenvalues.\n\n        Parameters\n        ----------\n        left: float\n              The left end of the interval.\n        right: float\n              The right end of the interval.\n\n        Notes\n        -----\n        The filter will be most effective if the numerical range is tight,\n        that is, left and right are good approximations to the leftmost and\n        rightmost eigenvalues, respectively.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_71setFilterRange(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_left = 0;
  PyObject *__pyx_v_right = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFilterRange (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_left,&__pyx_n_s_right,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_left)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_right)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setFilterRange", 1, 2, 2, 1); __PYX_ERR(0, 601, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setFilterRange") < 0)) __PYX_ERR(0, 601, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_left = values[0];
    __pyx_v_right = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setFilterRange", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 601, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setFilterRange", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_70setFilterRange(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_left, __pyx_v_right);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_70setFilterRange(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_left, PyObject *__pyx_v_right) {
  PetscReal __pyx_v_rval1;
  PetscReal __pyx_v_rval2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFilterRange", 0);

  /* "SLEPc/ST.pyx":619
 *         rightmost eigenvalues, respectively.
 *         """
 *         cdef PetscReal rval1 = asReal(left)             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval2 = asReal(right)
 *         CHKERR( STFilterSetRange(self.st, rval1, rval2) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_left); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(0, 619, __pyx_L1_error)
  __pyx_v_rval1 = __pyx_t_1;

  /* "SLEPc/ST.pyx":620
 *         """
 *         cdef PetscReal rval1 = asReal(left)
 *         cdef PetscReal rval2 = asReal(right)             # <<<<<<<<<<<<<<
 *         CHKERR( STFilterSetRange(self.st, rval1, rval2) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_right); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(0, 620, __pyx_L1_error)
  __pyx_v_rval2 = __pyx_t_1;

  /* "SLEPc/ST.pyx":621
 *         cdef PetscReal rval1 = asReal(left)
 *         cdef PetscReal rval2 = asReal(right)
 *         CHKERR( STFilterSetRange(self.st, rval1, rval2) )             # <<<<<<<<<<<<<<
 * 
 *     def getFilterRange(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STFilterSetRange(__pyx_v_self->st, __pyx_v_rval1, __pyx_v_rval2)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 621, __pyx_L1_error)

  /* "SLEPc/ST.pyx":601
 *         return (toReal(inta), toReal(intb))
 * 
 *     def setFilterRange(self, left, right):             # <<<<<<<<<<<<<<
 *         """
 *         Defines the numerical range (or field of values) of the matrix, that is,
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setFilterRange", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":623
 *         CHKERR( STFilterSetRange(self.st, rval1, rval2) )
 * 
 *     def getFilterRange(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the interval containing all eigenvalues.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_73getFilterRange(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_72getFilterRange[] = "ST.getFilterRange(self)\n\n        Gets the interval containing all eigenvalues.\n\n        Returns\n        -------\n        left: float\n              The left end of the interval.\n        right: float\n              The right end of the interval.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_73getFilterRange(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getFilterRange (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getFilterRange", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getFilterRange", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_72getFilterRange(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_72getFilterRange(struct PySlepcSTObject *__pyx_v_self) {
  PetscReal __pyx_v_left;
  PetscReal __pyx_v_right;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getFilterRange", 0);

  /* "SLEPc/ST.pyx":634
 *               The right end of the interval.
 *         """
 *         cdef PetscReal left = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal right = 0
 *         CHKERR( STFilterGetRange(self.st, &left, &right) )
 */
  __pyx_v_left = 0.0;

  /* "SLEPc/ST.pyx":635
 *         """
 *         cdef PetscReal left = 0
 *         cdef PetscReal right = 0             # <<<<<<<<<<<<<<
 *         CHKERR( STFilterGetRange(self.st, &left, &right) )
 *         return (toReal(left), toReal(right))
 */
  __pyx_v_right = 0.0;

  /* "SLEPc/ST.pyx":636
 *         cdef PetscReal left = 0
 *         cdef PetscReal right = 0
 *         CHKERR( STFilterGetRange(self.st, &left, &right) )             # <<<<<<<<<<<<<<
 *         return (toReal(left), toReal(right))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STFilterGetRange(__pyx_v_self->st, (&__pyx_v_left), (&__pyx_v_right))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 636, __pyx_L1_error)

  /* "SLEPc/ST.pyx":637
 *         cdef PetscReal right = 0
 *         CHKERR( STFilterGetRange(self.st, &left, &right) )
 *         return (toReal(left), toReal(right))             # <<<<<<<<<<<<<<
 * 
 *     def setFilterDegree(self, deg):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_left); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 637, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_right); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 637, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 637, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":623
 *         CHKERR( STFilterSetRange(self.st, rval1, rval2) )
 * 
 *     def getFilterRange(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the interval containing all eigenvalues.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.getFilterRange", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":639
 *         return (toReal(left), toReal(right))
 * 
 *     def setFilterDegree(self, deg):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the degree of the filter polynomial.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_75setFilterDegree(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_74setFilterDegree[] = "ST.setFilterDegree(self, deg)\n\n        Sets the degree of the filter polynomial.\n\n        Parameters\n        ----------\n        deg: int\n             The polynomial degree.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_75setFilterDegree(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_deg = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFilterDegree (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_deg,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_deg)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setFilterDegree") < 0)) __PYX_ERR(0, 639, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_deg = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setFilterDegree", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 639, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setFilterDegree", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_74setFilterDegree(((struct PySlepcSTObject *)__pyx_v_self), __pyx_v_deg);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_74setFilterDegree(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_deg) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFilterDegree", 0);

  /* "SLEPc/ST.pyx":648
 *              The polynomial degree.
 *         """
 *         cdef PetscInt val = asInt(deg)             # <<<<<<<<<<<<<<
 *         CHKERR( STFilterSetDegree(self.st, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_deg); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(0, 648, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/ST.pyx":649
 *         """
 *         cdef PetscInt val = asInt(deg)
 *         CHKERR( STFilterSetDegree(self.st, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getFilterDegree(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STFilterSetDegree(__pyx_v_self->st, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 649, __pyx_L1_error)

  /* "SLEPc/ST.pyx":639
 *         return (toReal(left), toReal(right))
 * 
 *     def setFilterDegree(self, deg):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the degree of the filter polynomial.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.setFilterDegree", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":651
 *         CHKERR( STFilterSetDegree(self.st, val) )
 * 
 *     def getFilterDegree(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the degree of the filter polynomial.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_77getFilterDegree(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2ST_76getFilterDegree[] = "ST.getFilterDegree(self)\n\n        Gets the degree of the filter polynomial.\n\n        Returns\n        -------\n        deg: int\n             The polynomial degree.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_77getFilterDegree(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getFilterDegree (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getFilterDegree", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getFilterDegree", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_76getFilterDegree(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_76getFilterDegree(struct PySlepcSTObject *__pyx_v_self) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getFilterDegree", 0);

  /* "SLEPc/ST.pyx":660
 *              The polynomial degree.
 *         """
 *         cdef PetscInt val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( STFilterGetDegree(self.st, &val) )
 *         return toInt(val)
 */
  __pyx_v_val = 0;

  /* "SLEPc/ST.pyx":661
 *         """
 *         cdef PetscInt val = 0
 *         CHKERR( STFilterGetDegree(self.st, &val) )             # <<<<<<<<<<<<<<
 *         return toInt(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(STFilterGetDegree(__pyx_v_self->st, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 661, __pyx_L1_error)

  /* "SLEPc/ST.pyx":662
 *         cdef PetscInt val = 0
 *         CHKERR( STFilterGetDegree(self.st, &val) )
 *         return toInt(val)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 662, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":651
 *         CHKERR( STFilterSetDegree(self.st, val) )
 * 
 *     def getFilterDegree(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the degree of the filter polynomial.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.getFilterDegree", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":667
 * 
 *     property shift:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getShift()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_5shift_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_5shift_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_5shift___get__(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_5shift___get__(struct PySlepcSTObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/ST.pyx":668
 *     property shift:
 *         def __get__(self):
 *             return self.getShift()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setShift(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getShift); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 668, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 668, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":667
 * 
 *     property shift:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getShift()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.shift.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":669
 *         def __get__(self):
 *             return self.getShift()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setShift(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2ST_5shift_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2ST_5shift_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_5shift_2__set__(((struct PySlepcSTObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2ST_5shift_2__set__(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/ST.pyx":670
 *             return self.getShift()
 *         def __set__(self, value):
 *             self.setShift(value)             # <<<<<<<<<<<<<<
 * 
 *     property transform:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setShift); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 670, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 670, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/ST.pyx":669
 *         def __get__(self):
 *             return self.getShift()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setShift(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.shift.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":673
 * 
 *     property transform:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTransform()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_9transform_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_9transform_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_9transform___get__(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_9transform___get__(struct PySlepcSTObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/ST.pyx":674
 *     property transform:
 *         def __get__(self):
 *             return self.getTransform()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTransform(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTransform); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 674, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 674, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":673
 * 
 *     property transform:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTransform()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.transform.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":675
 *         def __get__(self):
 *             return self.getTransform()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTransform(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2ST_9transform_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2ST_9transform_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_9transform_2__set__(((struct PySlepcSTObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2ST_9transform_2__set__(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/ST.pyx":676
 *             return self.getTransform()
 *         def __set__(self, value):
 *             self.setTransform(value)             # <<<<<<<<<<<<<<
 * 
 *     property mat_mode:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTransform); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 676, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 676, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/ST.pyx":675
 *         def __get__(self):
 *             return self.getTransform()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTransform(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.transform.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":679
 * 
 *     property mat_mode:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getMatMode()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_8mat_mode_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_8mat_mode_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_8mat_mode___get__(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_8mat_mode___get__(struct PySlepcSTObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/ST.pyx":680
 *     property mat_mode:
 *         def __get__(self):
 *             return self.getMatMode()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setMatMode(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getMatMode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 680, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 680, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":679
 * 
 *     property mat_mode:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getMatMode()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.mat_mode.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":681
 *         def __get__(self):
 *             return self.getMatMode()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setMatMode(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2ST_8mat_mode_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2ST_8mat_mode_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_8mat_mode_2__set__(((struct PySlepcSTObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2ST_8mat_mode_2__set__(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/ST.pyx":682
 *             return self.getMatMode()
 *         def __set__(self, value):
 *             self.setMatMode(value)             # <<<<<<<<<<<<<<
 * 
 *     property mat_structure:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setMatMode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 682, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 682, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/ST.pyx":681
 *         def __get__(self):
 *             return self.getMatMode()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setMatMode(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.mat_mode.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":685
 * 
 *     property mat_structure:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getMatStructure()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_13mat_structure_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_13mat_structure_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_13mat_structure___get__(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_13mat_structure___get__(struct PySlepcSTObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/ST.pyx":686
 *     property mat_structure:
 *         def __get__(self):
 *             return self.getMatStructure()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setMatStructure(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getMatStructure); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 686, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 686, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":685
 * 
 *     property mat_structure:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getMatStructure()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.mat_structure.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":687
 *         def __get__(self):
 *             return self.getMatStructure()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setMatStructure(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2ST_13mat_structure_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2ST_13mat_structure_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_13mat_structure_2__set__(((struct PySlepcSTObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2ST_13mat_structure_2__set__(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/ST.pyx":688
 *             return self.getMatStructure()
 *         def __set__(self, value):
 *             self.setMatStructure(value)             # <<<<<<<<<<<<<<
 * 
 *     property ksp:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setMatStructure); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 688, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 688, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/ST.pyx":687
 *         def __get__(self):
 *             return self.getMatStructure()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setMatStructure(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.mat_structure.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":691
 * 
 *     property ksp:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getKSP()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_3ksp_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2ST_3ksp_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_3ksp___get__(((struct PySlepcSTObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2ST_3ksp___get__(struct PySlepcSTObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/ST.pyx":692
 *     property ksp:
 *         def __get__(self):
 *             return self.getKSP()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setKSP(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getKSP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 692, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 692, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/ST.pyx":691
 * 
 *     property ksp:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getKSP()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.ksp.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/ST.pyx":693
 *         def __get__(self):
 *             return self.getKSP()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setKSP(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2ST_3ksp_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2ST_3ksp_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2ST_3ksp_2__set__(((struct PySlepcSTObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2ST_3ksp_2__set__(struct PySlepcSTObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/ST.pyx":694
 *             return self.getKSP()
 *         def __set__(self, value):
 *             self.setKSP(value)             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setKSP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 694, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 694, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/ST.pyx":693
 *         def __get__(self):
 *             return self.getKSP()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setKSP(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.ST.ksp.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":89
 *     MatMultType      = BVMatMultType
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.bv
 *         self.bv = NULL
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2BV_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2BV_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV___cinit__(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2BV___cinit__(struct PySlepcBVObject *__pyx_v_self) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "SLEPc/BV.pyx":90
 * 
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.bv             # <<<<<<<<<<<<<<
 *         self.bv = NULL
 * 
 */
  __pyx_v_self->__pyx_base.obj = ((PetscObject *)(&__pyx_v_self->bv));

  /* "SLEPc/BV.pyx":91
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.bv
 *         self.bv = NULL             # <<<<<<<<<<<<<<
 * 
 *     def view(self, Viewer viewer=None):
 */
  __pyx_v_self->bv = NULL;

  /* "SLEPc/BV.pyx":89
 *     MatMultType      = BVMatMultType
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.bv
 *         self.bv = NULL
 */

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":93
 *         self.bv = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the BV data structure.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_2view[] = "BV.view(self, Viewer viewer=None)\n\n        Prints the BV data structure.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("view (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "view") < 0)) __PYX_ERR(13, 93, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("view", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 93, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(13, 93, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_2view(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_2view(struct PySlepcBVObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("view", 0);

  /* "SLEPc/BV.pyx":103
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( BVView(self.bv, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/BV.pyx":104
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( BVView(self.bv, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def destroy(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVView(__pyx_v_self->bv, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 104, __pyx_L1_error)

  /* "SLEPc/BV.pyx":93
 *         self.bv = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the BV data structure.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":106
 *         CHKERR( BVView(self.bv, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the BV object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_4destroy[] = "BV.destroy(self)\n\n        Destroys the BV object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("destroy (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("destroy", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "destroy", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_4destroy(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_4destroy(struct PySlepcBVObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("destroy", 0);

  /* "SLEPc/BV.pyx":110
 *         Destroys the BV object.
 *         """
 *         CHKERR( BVDestroy(&self.bv) )             # <<<<<<<<<<<<<<
 *         self.bv = NULL
 *         return self
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVDestroy((&__pyx_v_self->bv))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 110, __pyx_L1_error)

  /* "SLEPc/BV.pyx":111
 *         """
 *         CHKERR( BVDestroy(&self.bv) )
 *         self.bv = NULL             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  __pyx_v_self->bv = NULL;

  /* "SLEPc/BV.pyx":112
 *         CHKERR( BVDestroy(&self.bv) )
 *         self.bv = NULL
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def create(self, comm=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":106
 *         CHKERR( BVView(self.bv, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the BV object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.destroy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":114
 *         return self
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the BV object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_7create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_6create[] = "BV.create(self, comm=None)\n\n        Creates the BV object.\n\n        Parameters\n        ----------\n        comm: Comm, optional\n              MPI communicator; if not provided, it defaults to all\n              processes.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_7create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comm = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comm,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comm);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create") < 0)) __PYX_ERR(13, 114, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_comm = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("create", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 114, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_6create(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_comm);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_6create(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_comm) {
  MPI_Comm __pyx_v_ccomm;
  BV __pyx_v_newbv;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  MPI_Comm __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("create", 0);

  /* "SLEPc/BV.pyx":124
 *               processes.
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())             # <<<<<<<<<<<<<<
 *         cdef SlepcBV newbv = NULL
 *         CHKERR( BVCreate(ccomm, &newbv) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_def_Comm(__pyx_v_comm, __pyx_f_8slepc4py_5SLEPc_SLEPC_COMM_DEFAULT()); if (unlikely(PyErr_Occurred())) __PYX_ERR(13, 124, __pyx_L1_error)
  __pyx_v_ccomm = __pyx_t_1;

  /* "SLEPc/BV.pyx":125
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcBV newbv = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( BVCreate(ccomm, &newbv) )
 *         SlepcCLEAR(self.obj); self.bv = newbv
 */
  __pyx_v_newbv = NULL;

  /* "SLEPc/BV.pyx":126
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcBV newbv = NULL
 *         CHKERR( BVCreate(ccomm, &newbv) )             # <<<<<<<<<<<<<<
 *         SlepcCLEAR(self.obj); self.bv = newbv
 *         return self
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVCreate(__pyx_v_ccomm, (&__pyx_v_newbv))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 126, __pyx_L1_error)

  /* "SLEPc/BV.pyx":127
 *         cdef SlepcBV newbv = NULL
 *         CHKERR( BVCreate(ccomm, &newbv) )
 *         SlepcCLEAR(self.obj); self.bv = newbv             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_SlepcCLEAR(__pyx_v_self->__pyx_base.obj));
  __pyx_v_self->bv = __pyx_v_newbv;

  /* "SLEPc/BV.pyx":128
 *         CHKERR( BVCreate(ccomm, &newbv) )
 *         SlepcCLEAR(self.obj); self.bv = newbv
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def createFromMat(self, Mat A):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":114
 *         return self
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the BV object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":130
 *         return self
 * 
 *     def createFromMat(self, Mat A):             # <<<<<<<<<<<<<<
 *         """
 *         Creates a basis vectors object from a dense Mat object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_9createFromMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_8createFromMat[] = "BV.createFromMat(self, Mat A)\n\n        Creates a basis vectors object from a dense Mat object.\n\n        Parameters\n        ----------\n        A: Mat\n           A dense tall-skinny matrix.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_9createFromMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("createFromMat (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_A,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_A)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "createFromMat") < 0)) __PYX_ERR(13, 130, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_A = ((struct PyPetscMatObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("createFromMat", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 130, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.createFromMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_A), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "A", 0))) __PYX_ERR(13, 130, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_8createFromMat(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_A);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_8createFromMat(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A) {
  BV __pyx_v_newbv;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("createFromMat", 0);

  /* "SLEPc/BV.pyx":139
 *            A dense tall-skinny matrix.
 *         """
 *         cdef SlepcBV newbv = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( BVCreateFromMat(A.mat, &newbv) )
 *         SlepcCLEAR(self.obj); self.bv = newbv
 */
  __pyx_v_newbv = NULL;

  /* "SLEPc/BV.pyx":140
 *         """
 *         cdef SlepcBV newbv = NULL
 *         CHKERR( BVCreateFromMat(A.mat, &newbv) )             # <<<<<<<<<<<<<<
 *         SlepcCLEAR(self.obj); self.bv = newbv
 *         return self
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVCreateFromMat(__pyx_v_A->mat, (&__pyx_v_newbv))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 140, __pyx_L1_error)

  /* "SLEPc/BV.pyx":141
 *         cdef SlepcBV newbv = NULL
 *         CHKERR( BVCreateFromMat(A.mat, &newbv) )
 *         SlepcCLEAR(self.obj); self.bv = newbv             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_SlepcCLEAR(__pyx_v_self->__pyx_base.obj));
  __pyx_v_self->bv = __pyx_v_newbv;

  /* "SLEPc/BV.pyx":142
 *         CHKERR( BVCreateFromMat(A.mat, &newbv) )
 *         SlepcCLEAR(self.obj); self.bv = newbv
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def createMat(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":130
 *         return self
 * 
 *     def createFromMat(self, Mat A):             # <<<<<<<<<<<<<<
 *         """
 *         Creates a basis vectors object from a dense Mat object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.createFromMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":144
 *         return self
 * 
 *     def createMat(self):             # <<<<<<<<<<<<<<
 *         """
 *         Creates a new Mat object of dense type and copies the contents of the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_11createMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_10createMat[] = "BV.createMat(self)\n\n        Creates a new Mat object of dense type and copies the contents of the\n        BV object.\n\n        Returns\n        -------\n        mat: the new matrix.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_11createMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("createMat (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("createMat", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "createMat", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_10createMat(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_10createMat(struct PySlepcBVObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_mat = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("createMat", 0);

  /* "SLEPc/BV.pyx":153
 *         mat: the new matrix.
 *         """
 *         cdef Mat mat = Mat()             # <<<<<<<<<<<<<<
 *         CHKERR( BVCreateMat(self.bv, &mat.mat) )
 *         return mat
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 153, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_mat = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/BV.pyx":154
 *         """
 *         cdef Mat mat = Mat()
 *         CHKERR( BVCreateMat(self.bv, &mat.mat) )             # <<<<<<<<<<<<<<
 *         return mat
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVCreateMat(__pyx_v_self->bv, (&__pyx_v_mat->mat))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 154, __pyx_L1_error)

  /* "SLEPc/BV.pyx":155
 *         cdef Mat mat = Mat()
 *         CHKERR( BVCreateMat(self.bv, &mat.mat) )
 *         return mat             # <<<<<<<<<<<<<<
 * 
 *     def duplicate(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_mat));
  __pyx_r = ((PyObject *)__pyx_v_mat);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":144
 *         return self
 * 
 *     def createMat(self):             # <<<<<<<<<<<<<<
 *         """
 *         Creates a new Mat object of dense type and copies the contents of the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.createMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_mat);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":157
 *         return mat
 * 
 *     def duplicate(self):             # <<<<<<<<<<<<<<
 *         """
 *         Duplicate the BV object with the same type and dimensions.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_13duplicate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_12duplicate[] = "BV.duplicate(self)\n\n        Duplicate the BV object with the same type and dimensions.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_13duplicate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("duplicate (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("duplicate", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "duplicate", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_12duplicate(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_12duplicate(struct PySlepcBVObject *__pyx_v_self) {
  struct PySlepcBVObject *__pyx_v_bv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("duplicate", 0);

  /* "SLEPc/BV.pyx":161
 *         Duplicate the BV object with the same type and dimensions.
 *         """
 *         cdef BV bv = type(self)()             # <<<<<<<<<<<<<<
 *         CHKERR( BVDuplicate(self.bv, &bv.bv) )
 *         return bv
 */
  __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
  __pyx_t_2 = ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))); __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 161, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_8slepc4py_5SLEPc_BV))))) __PYX_ERR(13, 161, __pyx_L1_error)
  __pyx_v_bv = ((struct PySlepcBVObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/BV.pyx":162
 *         """
 *         cdef BV bv = type(self)()
 *         CHKERR( BVDuplicate(self.bv, &bv.bv) )             # <<<<<<<<<<<<<<
 *         return bv
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVDuplicate(__pyx_v_self->bv, (&__pyx_v_bv->bv))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 162, __pyx_L1_error)

  /* "SLEPc/BV.pyx":163
 *         cdef BV bv = type(self)()
 *         CHKERR( BVDuplicate(self.bv, &bv.bv) )
 *         return bv             # <<<<<<<<<<<<<<
 * 
 *     def duplicateResize(self, m):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_bv));
  __pyx_r = ((PyObject *)__pyx_v_bv);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":157
 *         return mat
 * 
 *     def duplicate(self):             # <<<<<<<<<<<<<<
 *         """
 *         Duplicate the BV object with the same type and dimensions.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.duplicate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_bv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":165
 *         return bv
 * 
 *     def duplicateResize(self, m):             # <<<<<<<<<<<<<<
 *         """
 *         Creates a new BV object of the same type and dimensions as
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_15duplicateResize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_14duplicateResize[] = "BV.duplicateResize(self, m)\n\n        Creates a new BV object of the same type and dimensions as\n        an existing one, but with possibly different number of columns.\n\n        Parameters\n        ----------\n        m: int\n            The number of columns.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_15duplicateResize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_m = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("duplicateResize (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_m,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_m)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "duplicateResize") < 0)) __PYX_ERR(13, 165, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_m = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("duplicateResize", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 165, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.duplicateResize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_14duplicateResize(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_m);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_14duplicateResize(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_m) {
  struct PySlepcBVObject *__pyx_v_bv = 0;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PetscInt __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("duplicateResize", 0);

  /* "SLEPc/BV.pyx":175
 *             The number of columns.
 *         """
 *         cdef BV bv = type(self)()             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival = asInt(m)
 *         CHKERR( BVDuplicateResize(self.bv, ival, &bv.bv) )
 */
  __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
  __pyx_t_2 = ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))); __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 175, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_8slepc4py_5SLEPc_BV))))) __PYX_ERR(13, 175, __pyx_L1_error)
  __pyx_v_bv = ((struct PySlepcBVObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/BV.pyx":176
 *         """
 *         cdef BV bv = type(self)()
 *         cdef PetscInt ival = asInt(m)             # <<<<<<<<<<<<<<
 *         CHKERR( BVDuplicateResize(self.bv, ival, &bv.bv) )
 *         return bv
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_m); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 176, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_4;

  /* "SLEPc/BV.pyx":177
 *         cdef BV bv = type(self)()
 *         cdef PetscInt ival = asInt(m)
 *         CHKERR( BVDuplicateResize(self.bv, ival, &bv.bv) )             # <<<<<<<<<<<<<<
 *         return bv
 * 
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVDuplicateResize(__pyx_v_self->bv, __pyx_v_ival, (&__pyx_v_bv->bv))); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(13, 177, __pyx_L1_error)

  /* "SLEPc/BV.pyx":178
 *         cdef PetscInt ival = asInt(m)
 *         CHKERR( BVDuplicateResize(self.bv, ival, &bv.bv) )
 *         return bv             # <<<<<<<<<<<<<<
 * 
 *     def copy(self, BV result=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_bv));
  __pyx_r = ((PyObject *)__pyx_v_bv);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":165
 *         return bv
 * 
 *     def duplicateResize(self, m):             # <<<<<<<<<<<<<<
 *         """
 *         Creates a new BV object of the same type and dimensions as
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.duplicateResize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_bv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":180
 *         return bv
 * 
 *     def copy(self, BV result=None):             # <<<<<<<<<<<<<<
 *         """
 *         Copies a basis vector object into another one.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_17copy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_16copy[] = "BV.copy(self, BV result=None)\n\n        Copies a basis vector object into another one.\n\n        Parameters\n        ----------\n        result: `BV`, optional\n            The copy.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_17copy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcBVObject *__pyx_v_result = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("copy (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_result,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PySlepcBVObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_result);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "copy") < 0)) __PYX_ERR(13, 180, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_result = ((struct PySlepcBVObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("copy", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 180, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_result), __pyx_ptype_8slepc4py_5SLEPc_BV, 1, "result", 0))) __PYX_ERR(13, 180, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_16copy(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_result);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_16copy(struct PySlepcBVObject *__pyx_v_self, struct PySlepcBVObject *__pyx_v_result) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("copy", 0);
  __Pyx_INCREF((PyObject *)__pyx_v_result);

  /* "SLEPc/BV.pyx":189
 *             The copy.
 *         """
 *         if result is None:             # <<<<<<<<<<<<<<
 *             result = type(self)()
 *         if result.bv == NULL:
 */
  __pyx_t_1 = (((PyObject *)__pyx_v_result) == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "SLEPc/BV.pyx":190
 *         """
 *         if result is None:
 *             result = type(self)()             # <<<<<<<<<<<<<<
 *         if result.bv == NULL:
 *             CHKERR( BVDuplicate(self.bv, &result.bv) )
 */
    __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
    __pyx_t_4 = ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))); __pyx_t_5 = NULL;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
      if (likely(__pyx_t_5)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_4, function);
      }
    }
    __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 190, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8slepc4py_5SLEPc_BV))))) __PYX_ERR(13, 190, __pyx_L1_error)
    __Pyx_DECREF_SET(__pyx_v_result, ((struct PySlepcBVObject *)__pyx_t_3));
    __pyx_t_3 = 0;

    /* "SLEPc/BV.pyx":189
 *             The copy.
 *         """
 *         if result is None:             # <<<<<<<<<<<<<<
 *             result = type(self)()
 *         if result.bv == NULL:
 */
  }

  /* "SLEPc/BV.pyx":191
 *         if result is None:
 *             result = type(self)()
 *         if result.bv == NULL:             # <<<<<<<<<<<<<<
 *             CHKERR( BVDuplicate(self.bv, &result.bv) )
 *         CHKERR( BVCopy(self.bv, result.bv) )
 */
  __pyx_t_2 = ((__pyx_v_result->bv == NULL) != 0);
  if (__pyx_t_2) {

    /* "SLEPc/BV.pyx":192
 *             result = type(self)()
 *         if result.bv == NULL:
 *             CHKERR( BVDuplicate(self.bv, &result.bv) )             # <<<<<<<<<<<<<<
 *         CHKERR( BVCopy(self.bv, result.bv) )
 *         return result
 */
    __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVDuplicate(__pyx_v_self->bv, (&__pyx_v_result->bv))); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(13, 192, __pyx_L1_error)

    /* "SLEPc/BV.pyx":191
 *         if result is None:
 *             result = type(self)()
 *         if result.bv == NULL:             # <<<<<<<<<<<<<<
 *             CHKERR( BVDuplicate(self.bv, &result.bv) )
 *         CHKERR( BVCopy(self.bv, result.bv) )
 */
  }

  /* "SLEPc/BV.pyx":193
 *         if result.bv == NULL:
 *             CHKERR( BVDuplicate(self.bv, &result.bv) )
 *         CHKERR( BVCopy(self.bv, result.bv) )             # <<<<<<<<<<<<<<
 *         return result
 * 
 */
  __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVCopy(__pyx_v_self->bv, __pyx_v_result->bv)); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(13, 193, __pyx_L1_error)

  /* "SLEPc/BV.pyx":194
 *             CHKERR( BVDuplicate(self.bv, &result.bv) )
 *         CHKERR( BVCopy(self.bv, result.bv) )
 *         return result             # <<<<<<<<<<<<<<
 * 
 *     def setType(self, bv_type):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_result));
  __pyx_r = ((PyObject *)__pyx_v_result);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":180
 *         return bv
 * 
 *     def copy(self, BV result=None):             # <<<<<<<<<<<<<<
 *         """
 *         Copies a basis vector object into another one.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_result);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":196
 *         return result
 * 
 *     def setType(self, bv_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the type for the BV object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_19setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_18setType[] = "BV.setType(self, bv_type)\n\n        Selects the type for the BV object.\n\n        Parameters\n        ----------\n        bv_type: `BV.Type` enumerate\n                  The inner product type to be used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_19setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_bv_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bv_type,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bv_type)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setType") < 0)) __PYX_ERR(13, 196, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_bv_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 196, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_18setType(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_bv_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_18setType(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_bv_type) {
  const char* __pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setType", 0);
  __Pyx_INCREF(__pyx_v_bv_type);

  /* "SLEPc/BV.pyx":205
 *                   The inner product type to be used.
 *         """
 *         cdef SlepcBVType cval = NULL             # <<<<<<<<<<<<<<
 *         bv_type = str2bytes(bv_type, &cval)
 *         CHKERR( BVSetType(self.bv, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/BV.pyx":206
 *         """
 *         cdef SlepcBVType cval = NULL
 *         bv_type = str2bytes(bv_type, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( BVSetType(self.bv, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_bv_type, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 206, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_bv_type, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/BV.pyx":207
 *         cdef SlepcBVType cval = NULL
 *         bv_type = str2bytes(bv_type, &cval)
 *         CHKERR( BVSetType(self.bv, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getType(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetType(__pyx_v_self->bv, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 207, __pyx_L1_error)

  /* "SLEPc/BV.pyx":196
 *         return result
 * 
 *     def setType(self, bv_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the type for the BV object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_bv_type);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":209
 *         CHKERR( BVSetType(self.bv, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the BV type of this object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_21getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_20getType[] = "BV.getType(self)\n\n        Gets the BV type of this object.\n\n        Returns\n        -------\n        type: `BV.Type` enumerate\n              The inner product type currently being used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_21getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_20getType(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_20getType(struct PySlepcBVObject *__pyx_v_self) {
  const char* __pyx_v_bv_type;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getType", 0);

  /* "SLEPc/BV.pyx":218
 *               The inner product type currently being used.
 *         """
 *         cdef SlepcBVType bv_type = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetType(self.bv, &bv_type) )
 *         return bytes2str(bv_type)
 */
  __pyx_v_bv_type = NULL;

  /* "SLEPc/BV.pyx":219
 *         """
 *         cdef SlepcBVType bv_type = NULL
 *         CHKERR( BVGetType(self.bv, &bv_type) )             # <<<<<<<<<<<<<<
 *         return bytes2str(bv_type)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetType(__pyx_v_self->bv, (&__pyx_v_bv_type))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 219, __pyx_L1_error)

  /* "SLEPc/BV.pyx":220
 *         cdef SlepcBVType bv_type = NULL
 *         CHKERR( BVGetType(self.bv, &bv_type) )
 *         return bytes2str(bv_type)             # <<<<<<<<<<<<<<
 * 
 *     def setSizes(self, sizes, m):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_bv_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":209
 *         CHKERR( BVSetType(self.bv, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the BV type of this object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.getType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":222
 *         return bytes2str(bv_type)
 * 
 *     def setSizes(self, sizes, m):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the local and global sizes, and the number of columns.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_23setSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_22setSizes[] = "BV.setSizes(self, sizes, m)\n\n        Sets the local and global sizes, and the number of columns.\n\n        Parameters\n        ----------\n        sizes: int or two-tuple of int\n              The global size ``N`` or a two-tuple ``(n, N)``\n              with the local and global sizes.\n        m: int\n              The number of columns.\n\n        Notes\n        -----\n        Either ``n`` or ``N`` (but not both) can be ``PETSc.DECIDE``\n        or ``None`` to have it automatically set.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_23setSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_sizes = 0;
  PyObject *__pyx_v_m = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSizes (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sizes,&__pyx_n_s_m,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sizes)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_m)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setSizes", 1, 2, 2, 1); __PYX_ERR(13, 222, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSizes") < 0)) __PYX_ERR(13, 222, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_sizes = values[0];
    __pyx_v_m = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSizes", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 222, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setSizes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_22setSizes(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_sizes, __pyx_v_m);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_22setSizes(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_sizes, PyObject *__pyx_v_m) {
  PetscInt __pyx_v_n;
  PetscInt __pyx_v_N;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSizes", 0);

  /* "SLEPc/BV.pyx":239
 *         or ``None`` to have it automatically set.
 *         """
 *         cdef PetscInt n=0, N=0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival = asInt(m)
 *         BV_Sizes(sizes, &n, &N)
 */
  __pyx_v_n = 0;
  __pyx_v_N = 0;

  /* "SLEPc/BV.pyx":240
 *         """
 *         cdef PetscInt n=0, N=0
 *         cdef PetscInt ival = asInt(m)             # <<<<<<<<<<<<<<
 *         BV_Sizes(sizes, &n, &N)
 *         CHKERR( BVSetSizes(self.bv, n, N, ival) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_m); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 240, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/BV.pyx":241
 *         cdef PetscInt n=0, N=0
 *         cdef PetscInt ival = asInt(m)
 *         BV_Sizes(sizes, &n, &N)             # <<<<<<<<<<<<<<
 *         CHKERR( BVSetSizes(self.bv, n, N, ival) )
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_BV_Sizes(__pyx_v_sizes, (&__pyx_v_n), (&__pyx_v_N)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 241, __pyx_L1_error)

  /* "SLEPc/BV.pyx":242
 *         cdef PetscInt ival = asInt(m)
 *         BV_Sizes(sizes, &n, &N)
 *         CHKERR( BVSetSizes(self.bv, n, N, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def setSizesFromVec(self, Vec w, m):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetSizes(__pyx_v_self->bv, __pyx_v_n, __pyx_v_N, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 242, __pyx_L1_error)

  /* "SLEPc/BV.pyx":222
 *         return bytes2str(bv_type)
 * 
 *     def setSizes(self, sizes, m):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the local and global sizes, and the number of columns.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setSizes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":244
 *         CHKERR( BVSetSizes(self.bv, n, N, ival) )
 * 
 *     def setSizesFromVec(self, Vec w, m):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the local and global sizes, and the number of columns. Local and
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_25setSizesFromVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_24setSizesFromVec[] = "BV.setSizesFromVec(self, Vec w, m)\n\n        Sets the local and global sizes, and the number of columns. Local and\n        global sizes are specified indirectly by passing a template vector.\n\n        Parameters\n        ----------\n        w: Vec\n            The template vector.\n        m: int\n            The number of columns.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_25setSizesFromVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscVecObject *__pyx_v_w = 0;
  PyObject *__pyx_v_m = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSizesFromVec (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_w,&__pyx_n_s_m,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_w)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_m)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setSizesFromVec", 1, 2, 2, 1); __PYX_ERR(13, 244, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSizesFromVec") < 0)) __PYX_ERR(13, 244, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_w = ((struct PyPetscVecObject *)values[0]);
    __pyx_v_m = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSizesFromVec", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 244, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setSizesFromVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_w), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "w", 0))) __PYX_ERR(13, 244, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_24setSizesFromVec(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_w, __pyx_v_m);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_24setSizesFromVec(struct PySlepcBVObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_w, PyObject *__pyx_v_m) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSizesFromVec", 0);

  /* "SLEPc/BV.pyx":256
 *             The number of columns.
 *         """
 *         cdef PetscInt ival = asInt(m)             # <<<<<<<<<<<<<<
 *         CHKERR( BVSetSizesFromVec(self.bv, w.vec, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_m); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 256, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/BV.pyx":257
 *         """
 *         cdef PetscInt ival = asInt(m)
 *         CHKERR( BVSetSizesFromVec(self.bv, w.vec, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getSizes(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetSizesFromVec(__pyx_v_self->bv, __pyx_v_w->vec, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 257, __pyx_L1_error)

  /* "SLEPc/BV.pyx":244
 *         CHKERR( BVSetSizes(self.bv, n, N, ival) )
 * 
 *     def setSizesFromVec(self, Vec w, m):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the local and global sizes, and the number of columns. Local and
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setSizesFromVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":259
 *         CHKERR( BVSetSizesFromVec(self.bv, w.vec, ival) )
 * 
 *     def getSizes(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the local and global sizes, and the number of columns.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_27getSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_26getSizes[] = "BV.getSizes(self)\n\n        Returns the local and global sizes, and the number of columns.\n\n        Returns\n        -------\n        sizes: two-tuple of int\n                The local and global sizes ``(n, N)``.\n        m: int\n                The number of columns.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_27getSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSizes (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSizes", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSizes", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_26getSizes(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_26getSizes(struct PySlepcBVObject *__pyx_v_self) {
  PetscInt __pyx_v_n;
  PetscInt __pyx_v_N;
  PetscInt __pyx_v_m;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSizes", 0);

  /* "SLEPc/BV.pyx":270
 *                 The number of columns.
 *         """
 *         cdef PetscInt n=0, N=0, m=0             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetSizes(self.bv, &n, &N, &m) )
 *         return ((toInt(n), toInt(N)), toInt(m))
 */
  __pyx_v_n = 0;
  __pyx_v_N = 0;
  __pyx_v_m = 0;

  /* "SLEPc/BV.pyx":271
 *         """
 *         cdef PetscInt n=0, N=0, m=0
 *         CHKERR( BVGetSizes(self.bv, &n, &N, &m) )             # <<<<<<<<<<<<<<
 *         return ((toInt(n), toInt(N)), toInt(m))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetSizes(__pyx_v_self->bv, (&__pyx_v_n), (&__pyx_v_N), (&__pyx_v_m))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 271, __pyx_L1_error)

  /* "SLEPc/BV.pyx":272
 *         cdef PetscInt n=0, N=0, m=0
 *         CHKERR( BVGetSizes(self.bv, &n, &N, &m) )
 *         return ((toInt(n), toInt(N)), toInt(m))             # <<<<<<<<<<<<<<
 * 
 *     def setOptionsPrefix(self, prefix):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 272, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_N); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 272, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 272, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_m); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 272, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 272, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3);
  __pyx_t_4 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":259
 *         CHKERR( BVSetSizesFromVec(self.bv, w.vec, ival) )
 * 
 *     def getSizes(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the local and global sizes, and the number of columns.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.getSizes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":274
 *         return ((toInt(n), toInt(N)), toInt(m))
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all BV options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_29setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_28setOptionsPrefix[] = "BV.setOptionsPrefix(self, prefix)\n\n        Sets the prefix used for searching for all BV options in the\n        database.\n\n        Parameters\n        ----------\n        prefix: string\n                The prefix string to prepend to all BV option\n                requests.\n\n        Notes\n        -----\n        A hyphen (``-``) must NOT be given at the beginning of the\n        prefix name.  The first character of all runtime options is\n        AUTOMATICALLY the hyphen.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_29setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOptionsPrefix") < 0)) __PYX_ERR(13, 274, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 274, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_28setOptionsPrefix(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_28setOptionsPrefix(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/BV.pyx":291
 *         AUTOMATICALLY the hyphen.
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( BVSetOptionsPrefix(self.bv, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/BV.pyx":292
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( BVSetOptionsPrefix(self.bv, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 292, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/BV.pyx":293
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( BVSetOptionsPrefix(self.bv, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getOptionsPrefix(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetOptionsPrefix(__pyx_v_self->bv, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 293, __pyx_L1_error)

  /* "SLEPc/BV.pyx":274
 *         return ((toInt(n), toInt(N)), toInt(m))
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all BV options in the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":295
 *         CHKERR( BVSetOptionsPrefix(self.bv, cval) )
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all BV options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_31getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_30getOptionsPrefix[] = "BV.getOptionsPrefix(self)\n\n        Gets the prefix used for searching for all BV options in the\n        database.\n\n        Returns\n        -------\n        prefix: string\n                The prefix string set for this BV object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_31getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOptionsPrefix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOptionsPrefix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOptionsPrefix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_30getOptionsPrefix(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_30getOptionsPrefix(struct PySlepcBVObject *__pyx_v_self) {
  const char *__pyx_v_prefix;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOptionsPrefix", 0);

  /* "SLEPc/BV.pyx":305
 *                 The prefix string set for this BV object.
 *         """
 *         cdef const_char *prefix = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetOptionsPrefix(self.bv, &prefix) )
 *         return bytes2str(prefix)
 */
  __pyx_v_prefix = NULL;

  /* "SLEPc/BV.pyx":306
 *         """
 *         cdef const_char *prefix = NULL
 *         CHKERR( BVGetOptionsPrefix(self.bv, &prefix) )             # <<<<<<<<<<<<<<
 *         return bytes2str(prefix)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetOptionsPrefix(__pyx_v_self->bv, (&__pyx_v_prefix))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 306, __pyx_L1_error)

  /* "SLEPc/BV.pyx":307
 *         cdef const_char *prefix = NULL
 *         CHKERR( BVGetOptionsPrefix(self.bv, &prefix) )
 *         return bytes2str(prefix)             # <<<<<<<<<<<<<<
 * 
 *     def setFromOptions(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_prefix); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 307, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":295
 *         CHKERR( BVSetOptionsPrefix(self.bv, cval) )
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all BV options in the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.getOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":309
 *         return bytes2str(prefix)
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets BV options from the options database.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_33setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_32setFromOptions[] = "BV.setFromOptions(self)\n\n        Sets BV options from the options database.\n\n        Notes\n        -----\n        To see all options, run your program with the ``-help``\n        option.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_33setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFromOptions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setFromOptions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setFromOptions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_32setFromOptions(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_32setFromOptions(struct PySlepcBVObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFromOptions", 0);

  /* "SLEPc/BV.pyx":318
 *         option.
 *         """
 *         CHKERR( BVSetFromOptions(self.bv) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetFromOptions(__pyx_v_self->bv)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 318, __pyx_L1_error)

  /* "SLEPc/BV.pyx":309
 *         return bytes2str(prefix)
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets BV options from the options database.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setFromOptions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":322
 *     #
 * 
 *     def getOrthogonalization(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the orthogonalization settings from the BV object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_35getOrthogonalization(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_34getOrthogonalization[] = "BV.getOrthogonalization(self)\n\n        Gets the orthogonalization settings from the BV object.\n\n        Returns\n        -------\n        type: `BV.OrthogType` enumerate\n              The type of orthogonalization technique.\n        refine: `BV.OrthogRefineType` enumerate\n              The type of refinement.\n        eta:  float\n              Parameter for selective refinement (used when the\n              refinement type is `BV.OrthogRefineType.IFNEEDED`).\n        block: `BV.OrthogBlockType` enumerate\n              The type of block orthogonalization .\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_35getOrthogonalization(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOrthogonalization (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOrthogonalization", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOrthogonalization", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_34getOrthogonalization(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_34getOrthogonalization(struct PySlepcBVObject *__pyx_v_self) {
  BVOrthogType __pyx_v_val1;
  BVOrthogRefineType __pyx_v_val2;
  BVOrthogBlockType __pyx_v_val3;
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOrthogonalization", 0);

  /* "SLEPc/BV.pyx":338
 *               The type of block orthogonalization .
 *         """
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS             # <<<<<<<<<<<<<<
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 */
  __pyx_v_val1 = BV_ORTHOG_CGS;

  /* "SLEPc/BV.pyx":339
 *         """
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED             # <<<<<<<<<<<<<<
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 *         cdef PetscReal rval = PETSC_DEFAULT
 */
  __pyx_v_val2 = BV_ORTHOG_REFINE_IFNEEDED;

  /* "SLEPc/BV.pyx":340
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 */
  __pyx_v_val3 = BV_ORTHOG_BLOCK_GS;

  /* "SLEPc/BV.pyx":341
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 *         cdef PetscReal rval = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 *         return (val1, val2, toReal(rval), val3)
 */
  __pyx_v_rval = PETSC_DEFAULT;

  /* "SLEPc/BV.pyx":342
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )             # <<<<<<<<<<<<<<
 *         return (val1, val2, toReal(rval), val3)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetOrthogonalization(__pyx_v_self->bv, (&__pyx_v_val1), (&__pyx_v_val2), (&__pyx_v_rval), (&__pyx_v_val3))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 342, __pyx_L1_error)

  /* "SLEPc/BV.pyx":343
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 *         return (val1, val2, toReal(rval), val3)             # <<<<<<<<<<<<<<
 * 
 *     def setOrthogonalization(self, otype=None, refine=None, eta=None, block=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_BVOrthogType(__pyx_v_val1); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 343, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyInt_From_BVOrthogRefineType(__pyx_v_val2); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 343, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 343, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyInt_From_BVOrthogBlockType(__pyx_v_val3); if (unlikely(!__pyx_t_5)) __PYX_ERR(13, 343, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(13, 343, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_5);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_r = __pyx_t_6;
  __pyx_t_6 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":322
 *     #
 * 
 *     def getOrthogonalization(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the orthogonalization settings from the BV object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.getOrthogonalization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":345
 *         return (val1, val2, toReal(rval), val3)
 * 
 *     def setOrthogonalization(self, otype=None, refine=None, eta=None, block=None):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the method used for the orthogonalization of vectors
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_37setOrthogonalization(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_36setOrthogonalization[] = "BV.setOrthogonalization(self, otype=None, refine=None, eta=None, block=None)\n\n        Specifies the method used for the orthogonalization of vectors\n        (classical or modified Gram-Schmidt with or without refinement),\n        and for the block-orthogonalization (simultaneous orthogonalization\n        of a set of vectors).\n\n        Parameters\n        ----------\n        otype: `BV.OrthogType` enumerate, optional\n              The type of orthogonalization technique.\n        refine: `BV.OrthogRefineType` enumerate, optional\n              The type of refinement.\n        eta:  float, optional\n              Parameter for selective refinement.\n        block: `BV.OrthogBlockType` enumerate, optional\n              The type of block orthogonalization.\n\n        Notes\n        -----\n        The default settings work well for most problems.\n\n        The parameter `eta` should be a real value between ``0`` and\n        ``1`` (or `DEFAULT`).  The value of `eta` is used only when\n        the refinement type is `BV.OrthogRefineType.IFNEEDED`.\n\n        When using several processors, `BV.OrthogType.MGS` is likely to\n        result in bad scalability.\n\n        If the method set for block orthogonalization is GS, then the\n        computation is done column by column with the vector orthogonalization.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_37setOrthogonalization(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_otype = 0;
  PyObject *__pyx_v_refine = 0;
  PyObject *__pyx_v_eta = 0;
  PyObject *__pyx_v_block = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOrthogonalization (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_otype,&__pyx_n_s_refine,&__pyx_n_s_eta,&__pyx_n_s_block,0};
    PyObject* values[4] = {0,0,0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    values[3] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_otype);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_refine);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_eta);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_block);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOrthogonalization") < 0)) __PYX_ERR(13, 345, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_otype = values[0];
    __pyx_v_refine = values[1];
    __pyx_v_eta = values[2];
    __pyx_v_block = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOrthogonalization", 0, 0, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 345, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setOrthogonalization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_36setOrthogonalization(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_otype, __pyx_v_refine, __pyx_v_eta, __pyx_v_block);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_36setOrthogonalization(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_otype, PyObject *__pyx_v_refine, PyObject *__pyx_v_eta, PyObject *__pyx_v_block) {
  BVOrthogType __pyx_v_val1;
  BVOrthogRefineType __pyx_v_val2;
  BVOrthogBlockType __pyx_v_val3;
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  BVOrthogType __pyx_t_4;
  BVOrthogRefineType __pyx_t_5;
  BVOrthogBlockType __pyx_t_6;
  PetscReal __pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOrthogonalization", 0);

  /* "SLEPc/BV.pyx":377
 *         computation is done column by column with the vector orthogonalization.
 *         """
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS             # <<<<<<<<<<<<<<
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 */
  __pyx_v_val1 = BV_ORTHOG_CGS;

  /* "SLEPc/BV.pyx":378
 *         """
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED             # <<<<<<<<<<<<<<
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 *         cdef PetscReal rval = PETSC_DEFAULT
 */
  __pyx_v_val2 = BV_ORTHOG_REFINE_IFNEEDED;

  /* "SLEPc/BV.pyx":379
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 */
  __pyx_v_val3 = BV_ORTHOG_BLOCK_GS;

  /* "SLEPc/BV.pyx":380
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 *         cdef PetscReal rval = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 *         if otype  is not None: val1 = otype
 */
  __pyx_v_rval = PETSC_DEFAULT;

  /* "SLEPc/BV.pyx":381
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )             # <<<<<<<<<<<<<<
 *         if otype  is not None: val1 = otype
 *         if refine is not None: val2 = refine
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetOrthogonalization(__pyx_v_self->bv, (&__pyx_v_val1), (&__pyx_v_val2), (&__pyx_v_rval), (&__pyx_v_val3))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 381, __pyx_L1_error)

  /* "SLEPc/BV.pyx":382
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 *         if otype  is not None: val1 = otype             # <<<<<<<<<<<<<<
 *         if refine is not None: val2 = refine
 *         if block  is not None: val3 = block
 */
  __pyx_t_2 = (__pyx_v_otype != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = ((BVOrthogType)__Pyx_PyInt_As_BVOrthogType(__pyx_v_otype)); if (unlikely(PyErr_Occurred())) __PYX_ERR(13, 382, __pyx_L1_error)
    __pyx_v_val1 = __pyx_t_4;
  }

  /* "SLEPc/BV.pyx":383
 *         CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 *         if otype  is not None: val1 = otype
 *         if refine is not None: val2 = refine             # <<<<<<<<<<<<<<
 *         if block  is not None: val3 = block
 *         if eta    is not None: rval = asReal(eta)
 */
  __pyx_t_3 = (__pyx_v_refine != Py_None);
  __pyx_t_2 = (__pyx_t_3 != 0);
  if (__pyx_t_2) {
    __pyx_t_5 = ((BVOrthogRefineType)__Pyx_PyInt_As_BVOrthogRefineType(__pyx_v_refine)); if (unlikely(PyErr_Occurred())) __PYX_ERR(13, 383, __pyx_L1_error)
    __pyx_v_val2 = __pyx_t_5;
  }

  /* "SLEPc/BV.pyx":384
 *         if otype  is not None: val1 = otype
 *         if refine is not None: val2 = refine
 *         if block  is not None: val3 = block             # <<<<<<<<<<<<<<
 *         if eta    is not None: rval = asReal(eta)
 *         CHKERR( BVSetOrthogonalization(self.bv, val1, val2, rval, val3) )
 */
  __pyx_t_2 = (__pyx_v_block != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_6 = ((BVOrthogBlockType)__Pyx_PyInt_As_BVOrthogBlockType(__pyx_v_block)); if (unlikely(PyErr_Occurred())) __PYX_ERR(13, 384, __pyx_L1_error)
    __pyx_v_val3 = __pyx_t_6;
  }

  /* "SLEPc/BV.pyx":385
 *         if refine is not None: val2 = refine
 *         if block  is not None: val3 = block
 *         if eta    is not None: rval = asReal(eta)             # <<<<<<<<<<<<<<
 *         CHKERR( BVSetOrthogonalization(self.bv, val1, val2, rval, val3) )
 * 
 */
  __pyx_t_3 = (__pyx_v_eta != Py_None);
  __pyx_t_2 = (__pyx_t_3 != 0);
  if (__pyx_t_2) {
    __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_eta); if (unlikely(__pyx_t_7 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(13, 385, __pyx_L1_error)
    __pyx_v_rval = __pyx_t_7;
  }

  /* "SLEPc/BV.pyx":386
 *         if block  is not None: val3 = block
 *         if eta    is not None: rval = asReal(eta)
 *         CHKERR( BVSetOrthogonalization(self.bv, val1, val2, rval, val3) )             # <<<<<<<<<<<<<<
 * 
 *     def getMatMultMethod(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetOrthogonalization(__pyx_v_self->bv, __pyx_v_val1, __pyx_v_val2, __pyx_v_rval, __pyx_v_val3)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 386, __pyx_L1_error)

  /* "SLEPc/BV.pyx":345
 *         return (val1, val2, toReal(rval), val3)
 * 
 *     def setOrthogonalization(self, otype=None, refine=None, eta=None, block=None):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the method used for the orthogonalization of vectors
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setOrthogonalization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":388
 *         CHKERR( BVSetOrthogonalization(self.bv, val1, val2, rval, val3) )
 * 
 *     def getMatMultMethod(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the method used for the `matMult()` operation.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_39getMatMultMethod(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_38getMatMultMethod[] = "BV.getMatMultMethod(self)\n\n        Gets the method used for the `matMult()` operation.\n\n        Returns\n        -------\n        method: `BV.MatMultType` enumerate\n              The method for the `matMult()` operation.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_39getMatMultMethod(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getMatMultMethod (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getMatMultMethod", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getMatMultMethod", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_38getMatMultMethod(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_38getMatMultMethod(struct PySlepcBVObject *__pyx_v_self) {
  BVMatMultType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getMatMultMethod", 0);

  /* "SLEPc/BV.pyx":397
 *               The method for the `matMult()` operation.
 *         """
 *         cdef SlepcBVMatMultType val = BV_MATMULT_MAT             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetMatMultMethod(self.bv, &val) )
 *         return val
 */
  __pyx_v_val = BV_MATMULT_MAT;

  /* "SLEPc/BV.pyx":398
 *         """
 *         cdef SlepcBVMatMultType val = BV_MATMULT_MAT
 *         CHKERR( BVGetMatMultMethod(self.bv, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetMatMultMethod(__pyx_v_self->bv, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 398, __pyx_L1_error)

  /* "SLEPc/BV.pyx":399
 *         cdef SlepcBVMatMultType val = BV_MATMULT_MAT
 *         CHKERR( BVGetMatMultMethod(self.bv, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setMatMultMethod(self, method):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_BVMatMultType(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 399, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":388
 *         CHKERR( BVSetOrthogonalization(self.bv, val1, val2, rval, val3) )
 * 
 *     def getMatMultMethod(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the method used for the `matMult()` operation.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.getMatMultMethod", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":401
 *         return val
 * 
 *     def setMatMultMethod(self, method):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the method used for the `matMult()` operation.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_41setMatMultMethod(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_40setMatMultMethod[] = "BV.setMatMultMethod(self, method)\n\n        Specifies the method used for the `matMult()` operation.\n\n        Parameters\n        ----------\n        method: `BV.MatMultType` enumerate\n              The method for the `matMult()` operation.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_41setMatMultMethod(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_method = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setMatMultMethod (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_method,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_method)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setMatMultMethod") < 0)) __PYX_ERR(13, 401, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_method = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setMatMultMethod", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 401, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setMatMultMethod", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_40setMatMultMethod(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_method);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_40setMatMultMethod(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_method) {
  BVMatMultType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  BVMatMultType __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setMatMultMethod", 0);

  /* "SLEPc/BV.pyx":410
 *               The method for the `matMult()` operation.
 *         """
 *         cdef SlepcBVMatMultType val = method             # <<<<<<<<<<<<<<
 *         CHKERR( BVSetMatMultMethod(self.bv, val) )
 * 
 */
  __pyx_t_1 = ((BVMatMultType)__Pyx_PyInt_As_BVMatMultType(__pyx_v_method)); if (unlikely(PyErr_Occurred())) __PYX_ERR(13, 410, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/BV.pyx":411
 *         """
 *         cdef SlepcBVMatMultType val = method
 *         CHKERR( BVSetMatMultMethod(self.bv, val) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetMatMultMethod(__pyx_v_self->bv, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 411, __pyx_L1_error)

  /* "SLEPc/BV.pyx":401
 *         return val
 * 
 *     def setMatMultMethod(self, method):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the method used for the `matMult()` operation.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setMatMultMethod", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":415
 *     #
 * 
 *     def getMatrix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieves the matrix representation of the inner product.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_43getMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_42getMatrix[] = "BV.getMatrix(self)\n\n        Retrieves the matrix representation of the inner product.\n\n        Returns\n        -------\n        mat: the matrix of the inner product\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_43getMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getMatrix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getMatrix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getMatrix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_42getMatrix(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_42getMatrix(struct PySlepcBVObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_mat = 0;
  PetscBool __pyx_v_indef;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getMatrix", 0);

  /* "SLEPc/BV.pyx":423
 *         mat: the matrix of the inner product
 *         """
 *         cdef Mat mat = Mat()             # <<<<<<<<<<<<<<
 *         cdef PetscBool indef = PETSC_FALSE
 *         CHKERR( BVGetMatrix(self.bv, &mat.mat, &indef) )
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 423, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_mat = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/BV.pyx":424
 *         """
 *         cdef Mat mat = Mat()
 *         cdef PetscBool indef = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetMatrix(self.bv, &mat.mat, &indef) )
 *         PetscINCREF(mat.obj)
 */
  __pyx_v_indef = PETSC_FALSE;

  /* "SLEPc/BV.pyx":425
 *         cdef Mat mat = Mat()
 *         cdef PetscBool indef = PETSC_FALSE
 *         CHKERR( BVGetMatrix(self.bv, &mat.mat, &indef) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(mat.obj)
 *         return (mat, toBool(indef))
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetMatrix(__pyx_v_self->bv, (&__pyx_v_mat->mat), (&__pyx_v_indef))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 425, __pyx_L1_error)

  /* "SLEPc/BV.pyx":426
 *         cdef PetscBool indef = PETSC_FALSE
 *         CHKERR( BVGetMatrix(self.bv, &mat.mat, &indef) )
 *         PetscINCREF(mat.obj)             # <<<<<<<<<<<<<<
 *         return (mat, toBool(indef))
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_mat->__pyx_base.obj));

  /* "SLEPc/BV.pyx":427
 *         CHKERR( BVGetMatrix(self.bv, &mat.mat, &indef) )
 *         PetscINCREF(mat.obj)
 *         return (mat, toBool(indef))             # <<<<<<<<<<<<<<
 * 
 *     def setMatrix(self, Mat mat or None, bint indef):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_indef); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 427, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 427, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(((PyObject *)__pyx_v_mat));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_mat));
  PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_mat));
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
  __pyx_t_1 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":415
 *     #
 * 
 *     def getMatrix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieves the matrix representation of the inner product.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.getMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_mat);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":429
 *         return (mat, toBool(indef))
 * 
 *     def setMatrix(self, Mat mat or None, bint indef):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the bilinear form to be used for inner products.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_45setMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_44setMatrix[] = "BV.setMatrix(self, Mat mat, bool indef)\n\n        Sets the bilinear form to be used for inner products.\n\n        Parameters\n        ----------\n        mat:  Mat or None\n              The matrix of the inner product.\n        indef: bool, optional\n               Whether the matrix is indefinite\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_45setMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_mat = 0;
  int __pyx_v_indef;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setMatrix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_mat,&__pyx_n_s_indef,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mat)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_indef)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setMatrix", 1, 2, 2, 1); __PYX_ERR(13, 429, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setMatrix") < 0)) __PYX_ERR(13, 429, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_mat = ((struct PyPetscMatObject *)values[0]);
    __pyx_v_indef = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_indef == (int)-1) && PyErr_Occurred())) __PYX_ERR(13, 429, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setMatrix", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 429, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_mat), __pyx_ptype_8petsc4py_5PETSc_Mat, 1, "mat", 0))) __PYX_ERR(13, 429, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_44setMatrix(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_mat, __pyx_v_indef);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_44setMatrix(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_mat, int __pyx_v_indef) {
  Mat __pyx_v_m;
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Mat __pyx_t_1;
  int __pyx_t_2;
  PetscBool __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setMatrix", 0);

  /* "SLEPc/BV.pyx":440
 *                Whether the matrix is indefinite
 *         """
 *         cdef PetscMat m = <PetscMat>NULL if mat is None else mat.mat             # <<<<<<<<<<<<<<
 *         cdef PetscBool tval = PETSC_TRUE if indef else PETSC_FALSE
 *         CHKERR( BVSetMatrix(self.bv, m, tval) )
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_mat) == Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = ((Mat)NULL);
  } else {
    __pyx_t_1 = __pyx_v_mat->mat;
  }
  __pyx_v_m = __pyx_t_1;

  /* "SLEPc/BV.pyx":441
 *         """
 *         cdef PetscMat m = <PetscMat>NULL if mat is None else mat.mat
 *         cdef PetscBool tval = PETSC_TRUE if indef else PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( BVSetMatrix(self.bv, m, tval) )
 * 
 */
  if ((__pyx_v_indef != 0)) {
    __pyx_t_3 = PETSC_TRUE;
  } else {
    __pyx_t_3 = PETSC_FALSE;
  }
  __pyx_v_tval = __pyx_t_3;

  /* "SLEPc/BV.pyx":442
 *         cdef PetscMat m = <PetscMat>NULL if mat is None else mat.mat
 *         cdef PetscBool tval = PETSC_TRUE if indef else PETSC_FALSE
 *         CHKERR( BVSetMatrix(self.bv, m, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def applyMatrix(self, Vec x, Vec y):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetMatrix(__pyx_v_self->bv, __pyx_v_m, __pyx_v_tval)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 442, __pyx_L1_error)

  /* "SLEPc/BV.pyx":429
 *         return (mat, toBool(indef))
 * 
 *     def setMatrix(self, Mat mat or None, bint indef):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the bilinear form to be used for inner products.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":444
 *         CHKERR( BVSetMatrix(self.bv, m, tval) )
 * 
 *     def applyMatrix(self, Vec x, Vec y):             # <<<<<<<<<<<<<<
 *         """
 *         Multiplies a vector with the matrix associated to the bilinear
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_47applyMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_46applyMatrix[] = "BV.applyMatrix(self, Vec x, Vec y)\n\n        Multiplies a vector with the matrix associated to the bilinear\n        form.\n\n        Parameters\n        ----------\n        x: Vec\n           The input vector.\n        y: Vec\n           The result vector.\n\n        Notes\n        -----\n        If the bilinear form has no associated matrix this function\n        copies the vector.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_47applyMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscVecObject *__pyx_v_x = 0;
  struct PyPetscVecObject *__pyx_v_y = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("applyMatrix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("applyMatrix", 1, 2, 2, 1); __PYX_ERR(13, 444, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "applyMatrix") < 0)) __PYX_ERR(13, 444, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_x = ((struct PyPetscVecObject *)values[0]);
    __pyx_v_y = ((struct PyPetscVecObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("applyMatrix", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 444, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.applyMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_x), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "x", 0))) __PYX_ERR(13, 444, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "y", 0))) __PYX_ERR(13, 444, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_46applyMatrix(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_x, __pyx_v_y);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_46applyMatrix(struct PySlepcBVObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_x, struct PyPetscVecObject *__pyx_v_y) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("applyMatrix", 0);

  /* "SLEPc/BV.pyx":461
 *         copies the vector.
 *         """
 *         CHKERR( BVApplyMatrix(self.bv, x.vec, y.vec) )             # <<<<<<<<<<<<<<
 * 
 *     def setActiveColumns(self, l, k):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVApplyMatrix(__pyx_v_self->bv, __pyx_v_x->vec, __pyx_v_y->vec)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 461, __pyx_L1_error)

  /* "SLEPc/BV.pyx":444
 *         CHKERR( BVSetMatrix(self.bv, m, tval) )
 * 
 *     def applyMatrix(self, Vec x, Vec y):             # <<<<<<<<<<<<<<
 *         """
 *         Multiplies a vector with the matrix associated to the bilinear
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.applyMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":463
 *         CHKERR( BVApplyMatrix(self.bv, x.vec, y.vec) )
 * 
 *     def setActiveColumns(self, l, k):             # <<<<<<<<<<<<<<
 *         """
 *         Specify the columns that will be involved in operations.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_49setActiveColumns(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_48setActiveColumns[] = "BV.setActiveColumns(self, l, k)\n\n        Specify the columns that will be involved in operations.\n\n        Parameters\n        ----------\n        l: int\n            The leading number of columns.\n        k: int\n            The active number of columns.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_49setActiveColumns(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_l = 0;
  PyObject *__pyx_v_k = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setActiveColumns (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_l,&__pyx_n_s_k,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_l)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_k)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setActiveColumns", 1, 2, 2, 1); __PYX_ERR(13, 463, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setActiveColumns") < 0)) __PYX_ERR(13, 463, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_l = values[0];
    __pyx_v_k = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setActiveColumns", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 463, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setActiveColumns", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_48setActiveColumns(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_l, __pyx_v_k);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_48setActiveColumns(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_l, PyObject *__pyx_v_k) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setActiveColumns", 0);

  /* "SLEPc/BV.pyx":474
 *             The active number of columns.
 *         """
 *         cdef PetscInt ival1 = asInt(l)             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = asInt(k)
 *         CHKERR( BVSetActiveColumns(self.bv, ival1, ival2) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_l); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 474, __pyx_L1_error)
  __pyx_v_ival1 = __pyx_t_1;

  /* "SLEPc/BV.pyx":475
 *         """
 *         cdef PetscInt ival1 = asInt(l)
 *         cdef PetscInt ival2 = asInt(k)             # <<<<<<<<<<<<<<
 *         CHKERR( BVSetActiveColumns(self.bv, ival1, ival2) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_k); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 475, __pyx_L1_error)
  __pyx_v_ival2 = __pyx_t_1;

  /* "SLEPc/BV.pyx":476
 *         cdef PetscInt ival1 = asInt(l)
 *         cdef PetscInt ival2 = asInt(k)
 *         CHKERR( BVSetActiveColumns(self.bv, ival1, ival2) )             # <<<<<<<<<<<<<<
 * 
 *     def getActiveColumns(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetActiveColumns(__pyx_v_self->bv, __pyx_v_ival1, __pyx_v_ival2)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 476, __pyx_L1_error)

  /* "SLEPc/BV.pyx":463
 *         CHKERR( BVApplyMatrix(self.bv, x.vec, y.vec) )
 * 
 *     def setActiveColumns(self, l, k):             # <<<<<<<<<<<<<<
 *         """
 *         Specify the columns that will be involved in operations.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setActiveColumns", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":478
 *         CHKERR( BVSetActiveColumns(self.bv, ival1, ival2) )
 * 
 *     def getActiveColumns(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the current active dimensions.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_51getActiveColumns(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_50getActiveColumns[] = "BV.getActiveColumns(self)\n\n        Returns the current active dimensions.\n\n        Returns\n        -------\n        l: int\n            The leading number of columns.\n        k: int\n            The active number of columns.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_51getActiveColumns(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getActiveColumns (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getActiveColumns", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getActiveColumns", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_50getActiveColumns(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_50getActiveColumns(struct PySlepcBVObject *__pyx_v_self) {
  PetscInt __pyx_v_l;
  PetscInt __pyx_v_k;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getActiveColumns", 0);

  /* "SLEPc/BV.pyx":489
 *             The active number of columns.
 *         """
 *         cdef PetscInt l=0, k=0             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetActiveColumns(self.bv, &l, &k) )
 *         return (toInt(l), toInt(k))
 */
  __pyx_v_l = 0;
  __pyx_v_k = 0;

  /* "SLEPc/BV.pyx":490
 *         """
 *         cdef PetscInt l=0, k=0
 *         CHKERR( BVGetActiveColumns(self.bv, &l, &k) )             # <<<<<<<<<<<<<<
 *         return (toInt(l), toInt(k))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetActiveColumns(__pyx_v_self->bv, (&__pyx_v_l), (&__pyx_v_k))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 490, __pyx_L1_error)

  /* "SLEPc/BV.pyx":491
 *         cdef PetscInt l=0, k=0
 *         CHKERR( BVGetActiveColumns(self.bv, &l, &k) )
 *         return (toInt(l), toInt(k))             # <<<<<<<<<<<<<<
 * 
 *     def scaleColumn(self, j, alpha):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_l); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 491, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_k); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 491, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 491, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":478
 *         CHKERR( BVSetActiveColumns(self.bv, ival1, ival2) )
 * 
 *     def getActiveColumns(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the current active dimensions.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.getActiveColumns", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":493
 *         return (toInt(l), toInt(k))
 * 
 *     def scaleColumn(self, j, alpha):             # <<<<<<<<<<<<<<
 *         """
 *         Scale column j by alpha
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_53scaleColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_52scaleColumn[] = "BV.scaleColumn(self, j, alpha)\n\n        Scale column j by alpha\n\n        Parameters\n        ----------\n        j: int\n            column number to be scaled.\n        alpha: float\n            scaling factor.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_53scaleColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_j = 0;
  PyObject *__pyx_v_alpha = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("scaleColumn (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_j,&__pyx_n_s_alpha,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("scaleColumn", 1, 2, 2, 1); __PYX_ERR(13, 493, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "scaleColumn") < 0)) __PYX_ERR(13, 493, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_j = values[0];
    __pyx_v_alpha = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("scaleColumn", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 493, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.scaleColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_52scaleColumn(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_j, __pyx_v_alpha);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_52scaleColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j, PyObject *__pyx_v_alpha) {
  PetscInt __pyx_v_ival;
  PetscScalar __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  PetscScalar __pyx_t_2;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scaleColumn", 0);

  /* "SLEPc/BV.pyx":504
 *             scaling factor.
 *         """
 *         cdef PetscInt ival = asInt(j)             # <<<<<<<<<<<<<<
 *         cdef PetscScalar sval = asScalar(alpha)
 *         CHKERR( BVScaleColumn(self.bv, ival, sval) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_j); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 504, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/BV.pyx":505
 *         """
 *         cdef PetscInt ival = asInt(j)
 *         cdef PetscScalar sval = asScalar(alpha)             # <<<<<<<<<<<<<<
 *         CHKERR( BVScaleColumn(self.bv, ival, sval) )
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_alpha); if (unlikely(__pyx_t_2 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(13, 505, __pyx_L1_error)
  __pyx_v_sval = __pyx_t_2;

  /* "SLEPc/BV.pyx":506
 *         cdef PetscInt ival = asInt(j)
 *         cdef PetscScalar sval = asScalar(alpha)
 *         CHKERR( BVScaleColumn(self.bv, ival, sval) )             # <<<<<<<<<<<<<<
 * 
 *     def scale(self, alpha):
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVScaleColumn(__pyx_v_self->bv, __pyx_v_ival, __pyx_v_sval)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(13, 506, __pyx_L1_error)

  /* "SLEPc/BV.pyx":493
 *         return (toInt(l), toInt(k))
 * 
 *     def scaleColumn(self, j, alpha):             # <<<<<<<<<<<<<<
 *         """
 *         Scale column j by alpha
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.scaleColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":508
 *         CHKERR( BVScaleColumn(self.bv, ival, sval) )
 * 
 *     def scale(self, alpha):             # <<<<<<<<<<<<<<
 *         """
 *         Multiply the entries by a scalar value.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_55scale(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_54scale[] = "BV.scale(self, alpha)\n\n        Multiply the entries by a scalar value.\n\n        Parameters\n        ----------\n        alpha: float\n            scaling factor.\n\n        Notes\n        -----\n        All active columns (except the leading ones) are scaled.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_55scale(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_alpha = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("scale (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alpha,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "scale") < 0)) __PYX_ERR(13, 508, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_alpha = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("scale", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 508, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.scale", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_54scale(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_alpha);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_54scale(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_alpha) {
  PetscScalar __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("scale", 0);

  /* "SLEPc/BV.pyx":521
 *         All active columns (except the leading ones) are scaled.
 *         """
 *         cdef PetscScalar sval = asScalar(alpha)             # <<<<<<<<<<<<<<
 *         CHKERR( BVScale(self.bv, sval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_alpha); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(13, 521, __pyx_L1_error)
  __pyx_v_sval = __pyx_t_1;

  /* "SLEPc/BV.pyx":522
 *         """
 *         cdef PetscScalar sval = asScalar(alpha)
 *         CHKERR( BVScale(self.bv, sval) )             # <<<<<<<<<<<<<<
 * 
 *     def insertVec(self, j, Vec w):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVScale(__pyx_v_self->bv, __pyx_v_sval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 522, __pyx_L1_error)

  /* "SLEPc/BV.pyx":508
 *         CHKERR( BVScaleColumn(self.bv, ival, sval) )
 * 
 *     def scale(self, alpha):             # <<<<<<<<<<<<<<
 *         """
 *         Multiply the entries by a scalar value.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.scale", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":524
 *         CHKERR( BVScale(self.bv, sval) )
 * 
 *     def insertVec(self, j, Vec w):             # <<<<<<<<<<<<<<
 *         """
 *         Insert a vector into the specified column.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_57insertVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_56insertVec[] = "BV.insertVec(self, j, Vec w)\n\n        Insert a vector into the specified column.\n\n        Parameters\n        ----------\n        j: int\n            The column to be overwritten.\n        w: Vec\n            The vector to be copied.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_57insertVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_j = 0;
  struct PyPetscVecObject *__pyx_v_w = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("insertVec (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_j,&__pyx_n_s_w,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_w)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("insertVec", 1, 2, 2, 1); __PYX_ERR(13, 524, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "insertVec") < 0)) __PYX_ERR(13, 524, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_j = values[0];
    __pyx_v_w = ((struct PyPetscVecObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("insertVec", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 524, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.insertVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_w), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "w", 0))) __PYX_ERR(13, 524, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_56insertVec(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_j, __pyx_v_w);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_56insertVec(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j, struct PyPetscVecObject *__pyx_v_w) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("insertVec", 0);

  /* "SLEPc/BV.pyx":535
 *             The vector to be copied.
 *         """
 *         cdef PetscInt ival = asInt(j)             # <<<<<<<<<<<<<<
 *         CHKERR( BVInsertVec(self.bv, ival, w.vec) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_j); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 535, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/BV.pyx":536
 *         """
 *         cdef PetscInt ival = asInt(j)
 *         CHKERR( BVInsertVec(self.bv, ival, w.vec) )             # <<<<<<<<<<<<<<
 * 
 *     def insertVecs(self, s, W, bint orth):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVInsertVec(__pyx_v_self->bv, __pyx_v_ival, __pyx_v_w->vec)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 536, __pyx_L1_error)

  /* "SLEPc/BV.pyx":524
 *         CHKERR( BVScale(self.bv, sval) )
 * 
 *     def insertVec(self, j, Vec w):             # <<<<<<<<<<<<<<
 *         """
 *         Insert a vector into the specified column.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.insertVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":538
 *         CHKERR( BVInsertVec(self.bv, ival, w.vec) )
 * 
 *     def insertVecs(self, s, W, bint orth):             # <<<<<<<<<<<<<<
 *         """
 *         Insert a set of vectors into specified columns.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_59insertVecs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_58insertVecs[] = "BV.insertVecs(self, s, W, bool orth)\n\n        Insert a set of vectors into specified columns.\n\n        Parameters\n        ----------\n        s: int\n            The first column to be overwritten.\n        W: Vec or sequence of Vec.\n            Set of vectors to be copied.\n        orth:\n            Flag indicating if the vectors must be orthogonalized.\n\n        Returns\n        -------\n        m: int\n            Number of linearly independent vectors.\n\n        Notes\n        -----\n        Copies the contents of vectors W into self(:,s:s+n), where n is the\n        length of W. If orthogonalization flag is set then the vectors are\n        copied one by one then orthogonalized against the previous one.  If any\n        are linearly dependent then it is discared and the value of m is\n        decreased.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_59insertVecs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_s = 0;
  PyObject *__pyx_v_W = 0;
  int __pyx_v_orth;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("insertVecs (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_s,&__pyx_n_s_W,&__pyx_n_s_orth,0};
    PyObject* values[3] = {0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_s)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_W)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("insertVecs", 1, 3, 3, 1); __PYX_ERR(13, 538, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_orth)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("insertVecs", 1, 3, 3, 2); __PYX_ERR(13, 538, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "insertVecs") < 0)) __PYX_ERR(13, 538, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
    }
    __pyx_v_s = values[0];
    __pyx_v_W = values[1];
    __pyx_v_orth = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_orth == (int)-1) && PyErr_Occurred())) __PYX_ERR(13, 538, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("insertVecs", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 538, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.insertVecs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_58insertVecs(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_s, __pyx_v_W, __pyx_v_orth);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_58insertVecs(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_s, PyObject *__pyx_v_W, int __pyx_v_orth) {
  PetscInt __pyx_v_ival;
  Vec *__pyx_v_ws;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_ns;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PetscInt __pyx_v_m;
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PetscInt __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  Py_ssize_t __pyx_t_6;
  Py_ssize_t __pyx_t_7;
  Vec __pyx_t_8;
  PetscBool __pyx_t_9;
  int __pyx_t_10;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("insertVecs", 0);
  __Pyx_INCREF(__pyx_v_W);

  /* "SLEPc/BV.pyx":564
 *         decreased.
 *         """
 *         if isinstance(W, Vec): W = [W]             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival = asInt(s)
 *         cdef PetscVec *ws = NULL
 */
  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_W, __pyx_ptype_8petsc4py_5PETSc_Vec); 
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 564, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_W);
    __Pyx_GIVEREF(__pyx_v_W);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_W);
    __Pyx_DECREF_SET(__pyx_v_W, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/BV.pyx":565
 *         """
 *         if isinstance(W, Vec): W = [W]
 *         cdef PetscInt ival = asInt(s)             # <<<<<<<<<<<<<<
 *         cdef PetscVec *ws = NULL
 *         cdef Py_ssize_t i = 0, ns = len(W)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_s); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 565, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_4;

  /* "SLEPc/BV.pyx":566
 *         if isinstance(W, Vec): W = [W]
 *         cdef PetscInt ival = asInt(s)
 *         cdef PetscVec *ws = NULL             # <<<<<<<<<<<<<<
 *         cdef Py_ssize_t i = 0, ns = len(W)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&ws)
 */
  __pyx_v_ws = NULL;

  /* "SLEPc/BV.pyx":567
 *         cdef PetscInt ival = asInt(s)
 *         cdef PetscVec *ws = NULL
 *         cdef Py_ssize_t i = 0, ns = len(W)             # <<<<<<<<<<<<<<
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&ws)
 *         for i in range(ns): ws[i] = (<Vec?>W[i]).vec
 */
  __pyx_v_i = 0;
  __pyx_t_5 = PyObject_Length(__pyx_v_W); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(13, 567, __pyx_L1_error)
  __pyx_v_ns = __pyx_t_5;

  /* "SLEPc/BV.pyx":568
 *         cdef PetscVec *ws = NULL
 *         cdef Py_ssize_t i = 0, ns = len(W)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&ws)             # <<<<<<<<<<<<<<
 *         for i in range(ns): ws[i] = (<Vec?>W[i]).vec
 *         cdef PetscInt m = <PetscInt>ns
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_ns) * (sizeof(Vec))), ((void **)(&__pyx_v_ws))); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 568, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/BV.pyx":569
 *         cdef Py_ssize_t i = 0, ns = len(W)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&ws)
 *         for i in range(ns): ws[i] = (<Vec?>W[i]).vec             # <<<<<<<<<<<<<<
 *         cdef PetscInt m = <PetscInt>ns
 *         cdef PetscBool tval = PETSC_TRUE if orth else PETSC_FALSE
 */
  __pyx_t_5 = __pyx_v_ns;
  __pyx_t_6 = __pyx_t_5;
  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
    __pyx_v_i = __pyx_t_7;
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_W, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 569, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8petsc4py_5PETSc_Vec)))) __PYX_ERR(13, 569, __pyx_L1_error)
    __pyx_t_8 = ((struct PyPetscVecObject *)__pyx_t_3)->vec;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    (__pyx_v_ws[__pyx_v_i]) = __pyx_t_8;
  }

  /* "SLEPc/BV.pyx":570
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&ws)
 *         for i in range(ns): ws[i] = (<Vec?>W[i]).vec
 *         cdef PetscInt m = <PetscInt>ns             # <<<<<<<<<<<<<<
 *         cdef PetscBool tval = PETSC_TRUE if orth else PETSC_FALSE
 *         CHKERR( BVInsertVecs(self.bv, ival, &m, ws, tval) )
 */
  __pyx_v_m = ((PetscInt)__pyx_v_ns);

  /* "SLEPc/BV.pyx":571
 *         for i in range(ns): ws[i] = (<Vec?>W[i]).vec
 *         cdef PetscInt m = <PetscInt>ns
 *         cdef PetscBool tval = PETSC_TRUE if orth else PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( BVInsertVecs(self.bv, ival, &m, ws, tval) )
 *         return toInt(m)
 */
  if ((__pyx_v_orth != 0)) {
    __pyx_t_9 = PETSC_TRUE;
  } else {
    __pyx_t_9 = PETSC_FALSE;
  }
  __pyx_v_tval = __pyx_t_9;

  /* "SLEPc/BV.pyx":572
 *         cdef PetscInt m = <PetscInt>ns
 *         cdef PetscBool tval = PETSC_TRUE if orth else PETSC_FALSE
 *         CHKERR( BVInsertVecs(self.bv, ival, &m, ws, tval) )             # <<<<<<<<<<<<<<
 *         return toInt(m)
 * 
 */
  __pyx_t_10 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVInsertVecs(__pyx_v_self->bv, __pyx_v_ival, (&__pyx_v_m), __pyx_v_ws, __pyx_v_tval)); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(13, 572, __pyx_L1_error)

  /* "SLEPc/BV.pyx":573
 *         cdef PetscBool tval = PETSC_TRUE if orth else PETSC_FALSE
 *         CHKERR( BVInsertVecs(self.bv, ival, &m, ws, tval) )
 *         return toInt(m)             # <<<<<<<<<<<<<<
 * 
 *     def insertConstraints(self, C):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_m); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 573, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":538
 *         CHKERR( BVInsertVec(self.bv, ival, w.vec) )
 * 
 *     def insertVecs(self, s, W, bint orth):             # <<<<<<<<<<<<<<
 *         """
 *         Insert a set of vectors into specified columns.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.insertVecs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XDECREF(__pyx_v_W);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":575
 *         return toInt(m)
 * 
 *     def insertConstraints(self, C):             # <<<<<<<<<<<<<<
 *         """
 *         Insert a set of vectors as constraints.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_61insertConstraints(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_60insertConstraints[] = "BV.insertConstraints(self, C)\n\n        Insert a set of vectors as constraints.\n\n        Parameters\n        ----------\n        C: Vec or sequence of Vec.\n           Set of vectors to be inserted as constraints.\n\n        Returns\n        -------\n        nc: int\n            Number of linearly independent vectors.\n\n        Notes\n        -----\n        The constraints are relevant only during orthogonalization. Constraint\n        vectors span a subspace that is deflated in every orthogonalization\n        operation, so they are intended for removing those directions from the\n        orthogonal basis computed in regular BV columns.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_61insertConstraints(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_C = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("insertConstraints (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_C,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_C)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "insertConstraints") < 0)) __PYX_ERR(13, 575, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_C = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("insertConstraints", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 575, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.insertConstraints", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_60insertConstraints(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_C);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_60insertConstraints(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_C) {
  Vec *__pyx_v_cs;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_nc;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PetscInt __pyx_v_m;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  Py_ssize_t __pyx_t_6;
  Vec __pyx_t_7;
  int __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("insertConstraints", 0);
  __Pyx_INCREF(__pyx_v_C);

  /* "SLEPc/BV.pyx":596
 *         orthogonal basis computed in regular BV columns.
 *         """
 *         if isinstance(C, Vec): C = [C]             # <<<<<<<<<<<<<<
 *         cdef PetscVec *cs = NULL
 *         cdef Py_ssize_t i = 0, nc = len(C)
 */
  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_C, __pyx_ptype_8petsc4py_5PETSc_Vec); 
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 596, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_C);
    __Pyx_GIVEREF(__pyx_v_C);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_C);
    __Pyx_DECREF_SET(__pyx_v_C, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/BV.pyx":597
 *         """
 *         if isinstance(C, Vec): C = [C]
 *         cdef PetscVec *cs = NULL             # <<<<<<<<<<<<<<
 *         cdef Py_ssize_t i = 0, nc = len(C)
 *         cdef tmp = allocate(<size_t>nc*sizeof(PetscVec),<void**>&cs)
 */
  __pyx_v_cs = NULL;

  /* "SLEPc/BV.pyx":598
 *         if isinstance(C, Vec): C = [C]
 *         cdef PetscVec *cs = NULL
 *         cdef Py_ssize_t i = 0, nc = len(C)             # <<<<<<<<<<<<<<
 *         cdef tmp = allocate(<size_t>nc*sizeof(PetscVec),<void**>&cs)
 *         for i in range(nc): cs[i] = (<Vec?>C[i]).vec
 */
  __pyx_v_i = 0;
  __pyx_t_4 = PyObject_Length(__pyx_v_C); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(13, 598, __pyx_L1_error)
  __pyx_v_nc = __pyx_t_4;

  /* "SLEPc/BV.pyx":599
 *         cdef PetscVec *cs = NULL
 *         cdef Py_ssize_t i = 0, nc = len(C)
 *         cdef tmp = allocate(<size_t>nc*sizeof(PetscVec),<void**>&cs)             # <<<<<<<<<<<<<<
 *         for i in range(nc): cs[i] = (<Vec?>C[i]).vec
 *         cdef PetscInt m = <PetscInt>nc
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_nc) * (sizeof(Vec))), ((void **)(&__pyx_v_cs))); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 599, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/BV.pyx":600
 *         cdef Py_ssize_t i = 0, nc = len(C)
 *         cdef tmp = allocate(<size_t>nc*sizeof(PetscVec),<void**>&cs)
 *         for i in range(nc): cs[i] = (<Vec?>C[i]).vec             # <<<<<<<<<<<<<<
 *         cdef PetscInt m = <PetscInt>nc
 *         CHKERR( BVInsertConstraints(self.bv, &m, cs) )
 */
  __pyx_t_4 = __pyx_v_nc;
  __pyx_t_5 = __pyx_t_4;
  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
    __pyx_v_i = __pyx_t_6;
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_C, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 600, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8petsc4py_5PETSc_Vec)))) __PYX_ERR(13, 600, __pyx_L1_error)
    __pyx_t_7 = ((struct PyPetscVecObject *)__pyx_t_3)->vec;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    (__pyx_v_cs[__pyx_v_i]) = __pyx_t_7;
  }

  /* "SLEPc/BV.pyx":601
 *         cdef tmp = allocate(<size_t>nc*sizeof(PetscVec),<void**>&cs)
 *         for i in range(nc): cs[i] = (<Vec?>C[i]).vec
 *         cdef PetscInt m = <PetscInt>nc             # <<<<<<<<<<<<<<
 *         CHKERR( BVInsertConstraints(self.bv, &m, cs) )
 *         return toInt(m)
 */
  __pyx_v_m = ((PetscInt)__pyx_v_nc);

  /* "SLEPc/BV.pyx":602
 *         for i in range(nc): cs[i] = (<Vec?>C[i]).vec
 *         cdef PetscInt m = <PetscInt>nc
 *         CHKERR( BVInsertConstraints(self.bv, &m, cs) )             # <<<<<<<<<<<<<<
 *         return toInt(m)
 * 
 */
  __pyx_t_8 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVInsertConstraints(__pyx_v_self->bv, (&__pyx_v_m), __pyx_v_cs)); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(13, 602, __pyx_L1_error)

  /* "SLEPc/BV.pyx":603
 *         cdef PetscInt m = <PetscInt>nc
 *         CHKERR( BVInsertConstraints(self.bv, &m, cs) )
 *         return toInt(m)             # <<<<<<<<<<<<<<
 * 
 *     def setNumConstraints(self, nc):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_m); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 603, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":575
 *         return toInt(m)
 * 
 *     def insertConstraints(self, C):             # <<<<<<<<<<<<<<
 *         """
 *         Insert a set of vectors as constraints.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.insertConstraints", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XDECREF(__pyx_v_C);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":605
 *         return toInt(m)
 * 
 *     def setNumConstraints(self, nc):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of constraints.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_63setNumConstraints(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_62setNumConstraints[] = "BV.setNumConstraints(self, nc)\n\n        Sets the number of constraints.\n\n        Parameters\n        ----------\n        nc: int\n            The number of constraints.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_63setNumConstraints(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nc = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setNumConstraints (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nc,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nc)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNumConstraints") < 0)) __PYX_ERR(13, 605, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_nc = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setNumConstraints", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 605, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setNumConstraints", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_62setNumConstraints(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_nc);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_62setNumConstraints(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_nc) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setNumConstraints", 0);

  /* "SLEPc/BV.pyx":614
 *             The number of constraints.
 *         """
 *         cdef PetscInt val = asInt(nc)             # <<<<<<<<<<<<<<
 *         CHKERR( BVSetNumConstraints(self.bv, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_nc); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 614, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/BV.pyx":615
 *         """
 *         cdef PetscInt val = asInt(nc)
 *         CHKERR( BVSetNumConstraints(self.bv, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getNumConstraints(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetNumConstraints(__pyx_v_self->bv, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 615, __pyx_L1_error)

  /* "SLEPc/BV.pyx":605
 *         return toInt(m)
 * 
 *     def setNumConstraints(self, nc):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of constraints.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setNumConstraints", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":617
 *         CHKERR( BVSetNumConstraints(self.bv, val) )
 * 
 *     def getNumConstraints(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of constraints.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_65getNumConstraints(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_64getNumConstraints[] = "BV.getNumConstraints(self)\n\n        Gets the number of constraints.\n\n        Returns\n        -------\n        nc: int\n            The number of constraints.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_65getNumConstraints(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getNumConstraints (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getNumConstraints", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNumConstraints", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_64getNumConstraints(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_64getNumConstraints(struct PySlepcBVObject *__pyx_v_self) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getNumConstraints", 0);

  /* "SLEPc/BV.pyx":626
 *             The number of constraints.
 *         """
 *         cdef PetscInt val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetNumConstraints(self.bv, &val) )
 *         return toInt(val)
 */
  __pyx_v_val = 0;

  /* "SLEPc/BV.pyx":627
 *         """
 *         cdef PetscInt val = 0
 *         CHKERR( BVGetNumConstraints(self.bv, &val) )             # <<<<<<<<<<<<<<
 *         return toInt(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetNumConstraints(__pyx_v_self->bv, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 627, __pyx_L1_error)

  /* "SLEPc/BV.pyx":628
 *         cdef PetscInt val = 0
 *         CHKERR( BVGetNumConstraints(self.bv, &val) )
 *         return toInt(val)             # <<<<<<<<<<<<<<
 * 
 *     def createVec(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 628, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":617
 *         CHKERR( BVSetNumConstraints(self.bv, val) )
 * 
 *     def getNumConstraints(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of constraints.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.getNumConstraints", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":630
 *         return toInt(val)
 * 
 *     def createVec(self):             # <<<<<<<<<<<<<<
 *         """
 *         Creates a new Vec object with the same type and dimensions as
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_67createVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_66createVec[] = "BV.createVec(self)\n\n        Creates a new Vec object with the same type and dimensions as\n        the columns of the basis vectors object.\n\n        Returns\n        -------\n        v: Vec\n           New vector.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_67createVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("createVec (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("createVec", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "createVec", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_66createVec(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_66createVec(struct PySlepcBVObject *__pyx_v_self) {
  struct PyPetscVecObject *__pyx_v_v = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("createVec", 0);

  /* "SLEPc/BV.pyx":640
 *            New vector.
 *         """
 *         cdef Vec v = Vec()             # <<<<<<<<<<<<<<
 *         CHKERR( BVCreateVec(self.bv, &v.vec) )
 *         return v
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Vec)); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 640, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_v = ((struct PyPetscVecObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/BV.pyx":641
 *         """
 *         cdef Vec v = Vec()
 *         CHKERR( BVCreateVec(self.bv, &v.vec) )             # <<<<<<<<<<<<<<
 *         return v
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVCreateVec(__pyx_v_self->bv, (&__pyx_v_v->vec))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 641, __pyx_L1_error)

  /* "SLEPc/BV.pyx":642
 *         cdef Vec v = Vec()
 *         CHKERR( BVCreateVec(self.bv, &v.vec) )
 *         return v             # <<<<<<<<<<<<<<
 * 
 *     def copyVec(self, j, Vec v):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_v));
  __pyx_r = ((PyObject *)__pyx_v_v);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":630
 *         return toInt(val)
 * 
 *     def createVec(self):             # <<<<<<<<<<<<<<
 *         """
 *         Creates a new Vec object with the same type and dimensions as
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.createVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_v);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":644
 *         return v
 * 
 *     def copyVec(self, j, Vec v):             # <<<<<<<<<<<<<<
 *         """
 *         Copies one of the columns of a basis vectors object into a Vec.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_69copyVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_68copyVec[] = "BV.copyVec(self, j, Vec v)\n\n        Copies one of the columns of a basis vectors object into a Vec.\n\n        Parameters\n        ----------\n        j: int\n            The column number to be copied.\n        v: Vec\n            A vector.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_69copyVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_j = 0;
  struct PyPetscVecObject *__pyx_v_v = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("copyVec (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_j,&__pyx_n_s_v,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_v)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("copyVec", 1, 2, 2, 1); __PYX_ERR(13, 644, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "copyVec") < 0)) __PYX_ERR(13, 644, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_j = values[0];
    __pyx_v_v = ((struct PyPetscVecObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("copyVec", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 644, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.copyVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "v", 0))) __PYX_ERR(13, 644, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_68copyVec(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_j, __pyx_v_v);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_68copyVec(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j, struct PyPetscVecObject *__pyx_v_v) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("copyVec", 0);

  /* "SLEPc/BV.pyx":655
 *             A vector.
 *         """
 *         cdef PetscInt ival = asInt(j)             # <<<<<<<<<<<<<<
 *         CHKERR( BVCopyVec(self.bv, ival, v.vec) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_j); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 655, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/BV.pyx":656
 *         """
 *         cdef PetscInt ival = asInt(j)
 *         CHKERR( BVCopyVec(self.bv, ival, v.vec) )             # <<<<<<<<<<<<<<
 * 
 *     def copyColumn(self, j, i):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVCopyVec(__pyx_v_self->bv, __pyx_v_ival, __pyx_v_v->vec)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 656, __pyx_L1_error)

  /* "SLEPc/BV.pyx":644
 *         return v
 * 
 *     def copyVec(self, j, Vec v):             # <<<<<<<<<<<<<<
 *         """
 *         Copies one of the columns of a basis vectors object into a Vec.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.copyVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":658
 *         CHKERR( BVCopyVec(self.bv, ival, v.vec) )
 * 
 *     def copyColumn(self, j, i):             # <<<<<<<<<<<<<<
 *         """
 *         Copies the values from one of the columns to another one.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_71copyColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_70copyColumn[] = "BV.copyColumn(self, j, i)\n\n        Copies the values from one of the columns to another one.\n\n        Parameters\n        ----------\n        j: int\n            The number of the source column.\n        i: int\n            The number of the destination column.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_71copyColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_j = 0;
  PyObject *__pyx_v_i = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("copyColumn (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_j,&__pyx_n_s_i,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("copyColumn", 1, 2, 2, 1); __PYX_ERR(13, 658, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "copyColumn") < 0)) __PYX_ERR(13, 658, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_j = values[0];
    __pyx_v_i = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("copyColumn", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 658, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.copyColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_70copyColumn(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_j, __pyx_v_i);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_70copyColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j, PyObject *__pyx_v_i) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("copyColumn", 0);

  /* "SLEPc/BV.pyx":669
 *             The number of the destination column.
 *         """
 *         cdef PetscInt ival1 = asInt(j)             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = asInt(i)
 *         CHKERR( BVCopyColumn(self.bv, ival1, ival2) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_j); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 669, __pyx_L1_error)
  __pyx_v_ival1 = __pyx_t_1;

  /* "SLEPc/BV.pyx":670
 *         """
 *         cdef PetscInt ival1 = asInt(j)
 *         cdef PetscInt ival2 = asInt(i)             # <<<<<<<<<<<<<<
 *         CHKERR( BVCopyColumn(self.bv, ival1, ival2) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_i); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 670, __pyx_L1_error)
  __pyx_v_ival2 = __pyx_t_1;

  /* "SLEPc/BV.pyx":671
 *         cdef PetscInt ival1 = asInt(j)
 *         cdef PetscInt ival2 = asInt(i)
 *         CHKERR( BVCopyColumn(self.bv, ival1, ival2) )             # <<<<<<<<<<<<<<
 * 
 *     def setDefiniteTolerance(self, deftol):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVCopyColumn(__pyx_v_self->bv, __pyx_v_ival1, __pyx_v_ival2)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 671, __pyx_L1_error)

  /* "SLEPc/BV.pyx":658
 *         CHKERR( BVCopyVec(self.bv, ival, v.vec) )
 * 
 *     def copyColumn(self, j, i):             # <<<<<<<<<<<<<<
 *         """
 *         Copies the values from one of the columns to another one.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.copyColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":673
 *         CHKERR( BVCopyColumn(self.bv, ival1, ival2) )
 * 
 *     def setDefiniteTolerance(self, deftol):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance to be used when checking a definite inner product.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_73setDefiniteTolerance(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_72setDefiniteTolerance[] = "BV.setDefiniteTolerance(self, deftol)\n\n        Sets the tolerance to be used when checking a definite inner product.\n\n        Parameters\n        ----------\n        deftol: float\n             The tolerance.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_73setDefiniteTolerance(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_deftol = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setDefiniteTolerance (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_deftol,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_deftol)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setDefiniteTolerance") < 0)) __PYX_ERR(13, 673, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_deftol = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setDefiniteTolerance", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 673, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setDefiniteTolerance", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_72setDefiniteTolerance(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_deftol);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_72setDefiniteTolerance(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_deftol) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setDefiniteTolerance", 0);

  /* "SLEPc/BV.pyx":682
 *              The tolerance.
 *         """
 *         cdef PetscReal val = asReal(deftol)             # <<<<<<<<<<<<<<
 *         CHKERR( BVSetDefiniteTolerance(self.bv, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_deftol); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(13, 682, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/BV.pyx":683
 *         """
 *         cdef PetscReal val = asReal(deftol)
 *         CHKERR( BVSetDefiniteTolerance(self.bv, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getDefiniteTolerance(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetDefiniteTolerance(__pyx_v_self->bv, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 683, __pyx_L1_error)

  /* "SLEPc/BV.pyx":673
 *         CHKERR( BVCopyColumn(self.bv, ival1, ival2) )
 * 
 *     def setDefiniteTolerance(self, deftol):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance to be used when checking a definite inner product.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setDefiniteTolerance", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":685
 *         CHKERR( BVSetDefiniteTolerance(self.bv, val) )
 * 
 *     def getDefiniteTolerance(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance to be used when checking a definite inner product.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_75getDefiniteTolerance(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_74getDefiniteTolerance[] = "BV.getDefiniteTolerance(self)\n\n        Gets the tolerance to be used when checking a definite inner product.\n\n        Returns\n        -------\n        deftol: float\n             The tolerance.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_75getDefiniteTolerance(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDefiniteTolerance (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getDefiniteTolerance", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDefiniteTolerance", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_74getDefiniteTolerance(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_74getDefiniteTolerance(struct PySlepcBVObject *__pyx_v_self) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getDefiniteTolerance", 0);

  /* "SLEPc/BV.pyx":694
 *              The tolerance.
 *         """
 *         cdef PetscReal val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetDefiniteTolerance(self.bv, &val) )
 *         return toReal(val)
 */
  __pyx_v_val = 0.0;

  /* "SLEPc/BV.pyx":695
 *         """
 *         cdef PetscReal val = 0
 *         CHKERR( BVGetDefiniteTolerance(self.bv, &val) )             # <<<<<<<<<<<<<<
 *         return toReal(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetDefiniteTolerance(__pyx_v_self->bv, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 695, __pyx_L1_error)

  /* "SLEPc/BV.pyx":696
 *         cdef PetscReal val = 0
 *         CHKERR( BVGetDefiniteTolerance(self.bv, &val) )
 *         return toReal(val)             # <<<<<<<<<<<<<<
 * 
 *     def dotVec(self, Vec v):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 696, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":685
 *         CHKERR( BVSetDefiniteTolerance(self.bv, val) )
 * 
 *     def getDefiniteTolerance(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance to be used when checking a definite inner product.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.getDefiniteTolerance", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":698
 *         return toReal(val)
 * 
 *     def dotVec(self, Vec v):             # <<<<<<<<<<<<<<
 *         """
 *         Computes multiple dot products of a vector against all the column
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_77dotVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_76dotVec[] = "BV.dotVec(self, Vec v)\n\n        Computes multiple dot products of a vector against all the column\n        vectors of a BV.\n\n        Parameters\n        ----------\n        v: Vec\n            A vector.\n\n        Returns\n        -------\n        m: array of scalars\n            The computed values.\n\n        Notes\n        -----\n        This is analogue to VecMDot(), but using BV to represent a collection\n        of vectors. The result is m = X^H*y, so m_i is equal to x_j^H y. Note\n        that here X is transposed as opposed to BVDot().\n\n        If a non-standard inner product has been specified with BVSetMatrix(),\n        then the result is m = X^H*B*y.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_77dotVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscVecObject *__pyx_v_v = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("dotVec (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_v,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_v)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "dotVec") < 0)) __PYX_ERR(13, 698, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_v = ((struct PyPetscVecObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("dotVec", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 698, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.dotVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "v", 0))) __PYX_ERR(13, 698, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_76dotVec(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_v);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_76dotVec(struct PySlepcBVObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_v) {
  PyObject *__pyx_v_l = NULL;
  PyObject *__pyx_v_k = NULL;
  PetscScalar *__pyx_v_mval;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PyObject *__pyx_v_m = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *(*__pyx_t_5)(PyObject *);
  size_t __pyx_t_6;
  int __pyx_t_7;
  PetscInt __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("dotVec", 0);

  /* "SLEPc/BV.pyx":722
 *         then the result is m = X^H*B*y.
 *         """
 *         l, k = self.getActiveColumns()             # <<<<<<<<<<<<<<
 *         cdef PetscScalar* mval = NULL
 *         cdef tmp = allocate(<size_t>(k - l)*sizeof(PetscScalar), <void**>&mval)
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getActiveColumns); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 722, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 722, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
    PyObject* sequence = __pyx_t_1;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(13, 722, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); 
    } else {
      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
    }
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_3);
    #else
    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 722, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 722, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    #endif
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 722, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_5 = Py_TYPE(__pyx_t_4)->tp_iternext;
    index = 0; __pyx_t_2 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_2);
    index = 1; __pyx_t_3 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_3);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(13, 722, __pyx_L1_error)
    __pyx_t_5 = NULL;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    goto __pyx_L4_unpacking_done;
    __pyx_L3_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_5 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(13, 722, __pyx_L1_error)
    __pyx_L4_unpacking_done:;
  }
  __pyx_v_l = __pyx_t_2;
  __pyx_t_2 = 0;
  __pyx_v_k = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/BV.pyx":723
 *         """
 *         l, k = self.getActiveColumns()
 *         cdef PetscScalar* mval = NULL             # <<<<<<<<<<<<<<
 *         cdef tmp = allocate(<size_t>(k - l)*sizeof(PetscScalar), <void**>&mval)
 * 
 */
  __pyx_v_mval = NULL;

  /* "SLEPc/BV.pyx":724
 *         l, k = self.getActiveColumns()
 *         cdef PetscScalar* mval = NULL
 *         cdef tmp = allocate(<size_t>(k - l)*sizeof(PetscScalar), <void**>&mval)             # <<<<<<<<<<<<<<
 * 
 *         CHKERR( BVDotVec(self.bv, v.vec, mval) )
 */
  __pyx_t_1 = PyNumber_Subtract(__pyx_v_k, __pyx_v_l); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 724, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_6 = __Pyx_PyInt_As_size_t(__pyx_t_1); if (unlikely((__pyx_t_6 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(13, 724, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_t_6) * (sizeof(PetscScalar))), ((void **)(&__pyx_v_mval))); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 724, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_tmp = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/BV.pyx":726
 *         cdef tmp = allocate(<size_t>(k - l)*sizeof(PetscScalar), <void**>&mval)
 * 
 *         CHKERR( BVDotVec(self.bv, v.vec, mval) )             # <<<<<<<<<<<<<<
 * 
 *         cdef object m = None
 */
  __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVDotVec(__pyx_v_self->bv, __pyx_v_v->vec, __pyx_v_mval)); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(13, 726, __pyx_L1_error)

  /* "SLEPc/BV.pyx":728
 *         CHKERR( BVDotVec(self.bv, v.vec, mval) )
 * 
 *         cdef object m = None             # <<<<<<<<<<<<<<
 *         m = array_s(k - l, mval)
 *         return m
 */
  __Pyx_INCREF(Py_None);
  __pyx_v_m = Py_None;

  /* "SLEPc/BV.pyx":729
 * 
 *         cdef object m = None
 *         m = array_s(k - l, mval)             # <<<<<<<<<<<<<<
 *         return m
 * 
 */
  __pyx_t_1 = PyNumber_Subtract(__pyx_v_k, __pyx_v_l); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 729, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_8 = __Pyx_PyInt_As_PetscInt(__pyx_t_1); if (unlikely((__pyx_t_8 == ((PetscInt)-1)) && PyErr_Occurred())) __PYX_ERR(13, 729, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_s(__pyx_t_8, __pyx_v_mval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 729, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_m, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/BV.pyx":730
 *         cdef object m = None
 *         m = array_s(k - l, mval)
 *         return m             # <<<<<<<<<<<<<<
 * 
 *     def dotColumn(self, j):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_m);
  __pyx_r = __pyx_v_m;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":698
 *         return toReal(val)
 * 
 *     def dotVec(self, Vec v):             # <<<<<<<<<<<<<<
 *         """
 *         Computes multiple dot products of a vector against all the column
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.dotVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_l);
  __Pyx_XDECREF(__pyx_v_k);
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XDECREF(__pyx_v_m);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":732
 *         return m
 * 
 *     def dotColumn(self, j):             # <<<<<<<<<<<<<<
 *         """
 *         Computes multiple dot products of a column against all the column
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_79dotColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_78dotColumn[] = "BV.dotColumn(self, j)\n\n        Computes multiple dot products of a column against all the column\n        vectors of a BV.\n\n        Parameters\n        ----------\n        j: int\n            The index of the column.\n\n        Returns\n        -------\n        m: array of scalars\n            The computed values.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_79dotColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_j = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("dotColumn (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_j,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "dotColumn") < 0)) __PYX_ERR(13, 732, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_j = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("dotColumn", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 732, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.dotColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_78dotColumn(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_j);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_78dotColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_v_l = NULL;
  PyObject *__pyx_v_k = NULL;
  PetscScalar *__pyx_v_mval;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PyObject *__pyx_v_m = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *(*__pyx_t_6)(PyObject *);
  size_t __pyx_t_7;
  int __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("dotColumn", 0);

  /* "SLEPc/BV.pyx":747
 *             The computed values.
 *         """
 *         cdef PetscInt ival = asInt(j)             # <<<<<<<<<<<<<<
 *         l, k = self.getActiveColumns()
 *         cdef PetscScalar* mval = NULL
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_j); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 747, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/BV.pyx":748
 *         """
 *         cdef PetscInt ival = asInt(j)
 *         l, k = self.getActiveColumns()             # <<<<<<<<<<<<<<
 *         cdef PetscScalar* mval = NULL
 *         cdef tmp = allocate(<size_t>(k - l)*sizeof(PetscScalar), <void**>&mval)
 */
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getActiveColumns); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 748, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 748, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
    PyObject* sequence = __pyx_t_2;
    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(13, 748, __pyx_L1_error)
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
    } else {
      __pyx_t_3 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_4 = PyList_GET_ITEM(sequence, 1); 
    }
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_4);
    #else
    __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 748, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 748, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    #endif
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_5 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(13, 748, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
    index = 0; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_3);
    index = 1; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_4);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 2) < 0) __PYX_ERR(13, 748, __pyx_L1_error)
    __pyx_t_6 = NULL;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L4_unpacking_done;
    __pyx_L3_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_6 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(13, 748, __pyx_L1_error)
    __pyx_L4_unpacking_done:;
  }
  __pyx_v_l = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_k = __pyx_t_4;
  __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":749
 *         cdef PetscInt ival = asInt(j)
 *         l, k = self.getActiveColumns()
 *         cdef PetscScalar* mval = NULL             # <<<<<<<<<<<<<<
 *         cdef tmp = allocate(<size_t>(k - l)*sizeof(PetscScalar), <void**>&mval)
 * 
 */
  __pyx_v_mval = NULL;

  /* "SLEPc/BV.pyx":750
 *         l, k = self.getActiveColumns()
 *         cdef PetscScalar* mval = NULL
 *         cdef tmp = allocate(<size_t>(k - l)*sizeof(PetscScalar), <void**>&mval)             # <<<<<<<<<<<<<<
 * 
 *         CHKERR( BVDotColumn(self.bv, ival, mval) )
 */
  __pyx_t_2 = PyNumber_Subtract(__pyx_v_k, __pyx_v_l); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 750, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_7 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(13, 750, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_t_7) * (sizeof(PetscScalar))), ((void **)(&__pyx_v_mval))); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 750, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_tmp = __pyx_t_2;
  __pyx_t_2 = 0;

  /* "SLEPc/BV.pyx":752
 *         cdef tmp = allocate(<size_t>(k - l)*sizeof(PetscScalar), <void**>&mval)
 * 
 *         CHKERR( BVDotColumn(self.bv, ival, mval) )             # <<<<<<<<<<<<<<
 * 
 *         cdef object m = None
 */
  __pyx_t_8 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVDotColumn(__pyx_v_self->bv, __pyx_v_ival, __pyx_v_mval)); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(13, 752, __pyx_L1_error)

  /* "SLEPc/BV.pyx":754
 *         CHKERR( BVDotColumn(self.bv, ival, mval) )
 * 
 *         cdef object m = None             # <<<<<<<<<<<<<<
 *         m = array_s(k - l, mval)
 *         return m
 */
  __Pyx_INCREF(Py_None);
  __pyx_v_m = Py_None;

  /* "SLEPc/BV.pyx":755
 * 
 *         cdef object m = None
 *         m = array_s(k - l, mval)             # <<<<<<<<<<<<<<
 *         return m
 * 
 */
  __pyx_t_2 = PyNumber_Subtract(__pyx_v_k, __pyx_v_l); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 755, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyInt_As_PetscInt(__pyx_t_2); if (unlikely((__pyx_t_1 == ((PetscInt)-1)) && PyErr_Occurred())) __PYX_ERR(13, 755, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_s(__pyx_t_1, __pyx_v_mval)); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 755, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF_SET(__pyx_v_m, __pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/BV.pyx":756
 *         cdef object m = None
 *         m = array_s(k - l, mval)
 *         return m             # <<<<<<<<<<<<<<
 * 
 *     def getColumn(self, j):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_m);
  __pyx_r = __pyx_v_m;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":732
 *         return m
 * 
 *     def dotColumn(self, j):             # <<<<<<<<<<<<<<
 *         """
 *         Computes multiple dot products of a column against all the column
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.dotColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_l);
  __Pyx_XDECREF(__pyx_v_k);
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XDECREF(__pyx_v_m);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":758
 *         return m
 * 
 *     def getColumn(self, j):             # <<<<<<<<<<<<<<
 *         """
 *         Returns a Vec object that contains the entries of the requested column
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_81getColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_80getColumn[] = "BV.getColumn(self, j)\n\n        Returns a Vec object that contains the entries of the requested column\n        of the basis vectors object.\n\n        Parameters\n        ----------\n        j: int\n            The index of the requested column.\n\n        Returns\n        -------\n        v: Vec\n            The vector containing the jth column.\n\n        Notes\n        -----\n        Modifying the returned Vec will change the BV entries as well.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_81getColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_j = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getColumn (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_j,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getColumn") < 0)) __PYX_ERR(13, 758, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_j = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getColumn", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 758, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.getColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_80getColumn(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_j);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_80getColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j) {
  struct PyPetscVecObject *__pyx_v_v = 0;
  CYTHON_UNUSED PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PetscInt __pyx_t_2;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getColumn", 0);

  /* "SLEPc/BV.pyx":777
 *         Modifying the returned Vec will change the BV entries as well.
 *         """
 *         cdef Vec v = Vec()             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival = asInt(j)
 *         CHKERR( BVGetColumn(self.bv, j, &v.vec) )
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Vec)); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 777, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_v = ((struct PyPetscVecObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/BV.pyx":778
 *         """
 *         cdef Vec v = Vec()
 *         cdef PetscInt ival = asInt(j)             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetColumn(self.bv, j, &v.vec) )
 *         PetscINCREF(v.obj)
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_j); if (unlikely(__pyx_t_2 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 778, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_2;

  /* "SLEPc/BV.pyx":779
 *         cdef Vec v = Vec()
 *         cdef PetscInt ival = asInt(j)
 *         CHKERR( BVGetColumn(self.bv, j, &v.vec) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(v.obj)
 *         return v
 */
  __pyx_t_2 = __Pyx_PyInt_As_PetscInt(__pyx_v_j); if (unlikely((__pyx_t_2 == ((PetscInt)-1)) && PyErr_Occurred())) __PYX_ERR(13, 779, __pyx_L1_error)
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetColumn(__pyx_v_self->bv, __pyx_t_2, (&__pyx_v_v->vec))); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(13, 779, __pyx_L1_error)

  /* "SLEPc/BV.pyx":780
 *         cdef PetscInt ival = asInt(j)
 *         CHKERR( BVGetColumn(self.bv, j, &v.vec) )
 *         PetscINCREF(v.obj)             # <<<<<<<<<<<<<<
 *         return v
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_v->__pyx_base.obj));

  /* "SLEPc/BV.pyx":781
 *         CHKERR( BVGetColumn(self.bv, j, &v.vec) )
 *         PetscINCREF(v.obj)
 *         return v             # <<<<<<<<<<<<<<
 * 
 *     def restoreColumn(self, j, Vec v):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_v));
  __pyx_r = ((PyObject *)__pyx_v_v);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":758
 *         return m
 * 
 *     def getColumn(self, j):             # <<<<<<<<<<<<<<
 *         """
 *         Returns a Vec object that contains the entries of the requested column
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.getColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_v);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":783
 *         return v
 * 
 *     def restoreColumn(self, j, Vec v):             # <<<<<<<<<<<<<<
 *         """
 *         Restore a column obtained with `getColumn()`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_83restoreColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_82restoreColumn[] = "BV.restoreColumn(self, j, Vec v)\n\n        Restore a column obtained with `getColumn()`.\n\n        Parameters\n        ----------\n        j: int\n            The index of the requested column.\n        v: Vec\n            The vector obtained with `getColumn()`.\n\n        Notes\n        -----\n        The arguments must match the corresponding call to `getColumn()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_83restoreColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_j = 0;
  struct PyPetscVecObject *__pyx_v_v = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("restoreColumn (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_j,&__pyx_n_s_v,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_v)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("restoreColumn", 1, 2, 2, 1); __PYX_ERR(13, 783, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "restoreColumn") < 0)) __PYX_ERR(13, 783, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_j = values[0];
    __pyx_v_v = ((struct PyPetscVecObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("restoreColumn", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 783, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.restoreColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "v", 0))) __PYX_ERR(13, 783, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_82restoreColumn(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_j, __pyx_v_v);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_82restoreColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j, struct PyPetscVecObject *__pyx_v_v) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("restoreColumn", 0);

  /* "SLEPc/BV.pyx":798
 *         The arguments must match the corresponding call to `getColumn()`.
 *         """
 *         cdef PetscInt ival = asInt(j)             # <<<<<<<<<<<<<<
 *         CHKERR( PetscObjectDereference(<PetscObject>v.vec) )
 *         CHKERR( BVRestoreColumn(self.bv, ival, &v.vec) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_j); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 798, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/BV.pyx":799
 *         """
 *         cdef PetscInt ival = asInt(j)
 *         CHKERR( PetscObjectDereference(<PetscObject>v.vec) )             # <<<<<<<<<<<<<<
 *         CHKERR( BVRestoreColumn(self.bv, ival, &v.vec) )
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscObjectDereference(((PetscObject)__pyx_v_v->vec))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 799, __pyx_L1_error)

  /* "SLEPc/BV.pyx":800
 *         cdef PetscInt ival = asInt(j)
 *         CHKERR( PetscObjectDereference(<PetscObject>v.vec) )
 *         CHKERR( BVRestoreColumn(self.bv, ival, &v.vec) )             # <<<<<<<<<<<<<<
 * 
 *     def getMat(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVRestoreColumn(__pyx_v_self->bv, __pyx_v_ival, (&__pyx_v_v->vec))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 800, __pyx_L1_error)

  /* "SLEPc/BV.pyx":783
 *         return v
 * 
 *     def restoreColumn(self, j, Vec v):             # <<<<<<<<<<<<<<
 *         """
 *         Restore a column obtained with `getColumn()`.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.restoreColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":802
 *         CHKERR( BVRestoreColumn(self.bv, ival, &v.vec) )
 * 
 *     def getMat(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns a Mat object of dense type that shares the memory
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_85getMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_84getMat[] = "BV.getMat(self)\n\n        Returns a Mat object of dense type that shares the memory\n        of the basis vectors object.\n\n        Returns\n        -------\n        A: Mat\n           The matrix\n\n        Notes\n        -----\n        The returned matrix contains only the active columns. If the content\n        of the Mat is modified, these changes are also done in the BV object.\n        The user must call `restoreMat()` when no longer needed.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_85getMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getMat (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getMat", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getMat", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_84getMat(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_84getMat(struct PySlepcBVObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getMat", 0);

  /* "SLEPc/BV.pyx":818
 *         The user must call `restoreMat()` when no longer needed.
 *         """
 *         cdef Mat A = Mat()             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetMat(self.bv, &A.mat) )
 *         PetscINCREF(A.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 818, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_A = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/BV.pyx":819
 *         """
 *         cdef Mat A = Mat()
 *         CHKERR( BVGetMat(self.bv, &A.mat) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(A.obj)
 *         return A
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetMat(__pyx_v_self->bv, (&__pyx_v_A->mat))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 819, __pyx_L1_error)

  /* "SLEPc/BV.pyx":820
 *         cdef Mat A = Mat()
 *         CHKERR( BVGetMat(self.bv, &A.mat) )
 *         PetscINCREF(A.obj)             # <<<<<<<<<<<<<<
 *         return A
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_A->__pyx_base.obj));

  /* "SLEPc/BV.pyx":821
 *         CHKERR( BVGetMat(self.bv, &A.mat) )
 *         PetscINCREF(A.obj)
 *         return A             # <<<<<<<<<<<<<<
 * 
 *     def restoreMat(self, Mat A):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_A));
  __pyx_r = ((PyObject *)__pyx_v_A);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":802
 *         CHKERR( BVRestoreColumn(self.bv, ival, &v.vec) )
 * 
 *     def getMat(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns a Mat object of dense type that shares the memory
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.getMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_A);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":823
 *         return A
 * 
 *     def restoreMat(self, Mat A):             # <<<<<<<<<<<<<<
 *         """
 *         Restores the Mat obtained with `getMat()`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_87restoreMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_86restoreMat[] = "BV.restoreMat(self, Mat A)\n\n        Restores the Mat obtained with `getMat()`.\n\n        Parameters\n        ----------\n        A: Mat\n           The matrix obtained with `getMat()`.\n\n        Notes\n        -----\n        A call to this function must match a previous call of `getMat()`.\n        The effect is that the contents of the Mat are copied back to the\n        BV internal data structures.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_87restoreMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("restoreMat (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_A,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_A)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "restoreMat") < 0)) __PYX_ERR(13, 823, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_A = ((struct PyPetscMatObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("restoreMat", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 823, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.restoreMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_A), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "A", 0))) __PYX_ERR(13, 823, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_86restoreMat(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_A);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_86restoreMat(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("restoreMat", 0);

  /* "SLEPc/BV.pyx":838
 *         BV internal data structures.
 *         """
 *         CHKERR( PetscObjectDereference(<PetscObject>A.mat) )             # <<<<<<<<<<<<<<
 *         CHKERR( BVRestoreMat(self.bv, &A.mat) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscObjectDereference(((PetscObject)__pyx_v_A->mat))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 838, __pyx_L1_error)

  /* "SLEPc/BV.pyx":839
 *         """
 *         CHKERR( PetscObjectDereference(<PetscObject>A.mat) )
 *         CHKERR( BVRestoreMat(self.bv, &A.mat) )             # <<<<<<<<<<<<<<
 * 
 *     def dot(self, BV Y):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVRestoreMat(__pyx_v_self->bv, (&__pyx_v_A->mat))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 839, __pyx_L1_error)

  /* "SLEPc/BV.pyx":823
 *         return A
 * 
 *     def restoreMat(self, Mat A):             # <<<<<<<<<<<<<<
 *         """
 *         Restores the Mat obtained with `getMat()`.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.restoreMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":841
 *         CHKERR( BVRestoreMat(self.bv, &A.mat) )
 * 
 *     def dot(self, BV Y):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the 'block-dot' product of two basis vectors objects.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_89dot(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_88dot[] = "BV.dot(self, BV Y)\n\n        Computes the 'block-dot' product of two basis vectors objects.\n            M = Y^H*X (m_ij = y_i^H x_j) or M = Y^H*B*X\n\n        Parameters\n        ----------\n        Y: BV\n            Left basis vectors, can be the same as self, giving M = X^H X.\n\n        Returns\n        -------\n        M: Mat\n            The resulting matrix.\n\n        Notes\n        -----\n        This is the generalization of VecDot() for a collection of vectors, M =\n        Y^H*X. The result is a matrix M whose entry m_ij is equal to y_i^H x_j\n        (where y_i^H denotes the conjugate transpose of y_i).\n\n        X and Y can be the same object.\n\n        If a non-standard inner product has been specified with setMatrix(),\n        then the result is M = Y^H*B*X. In this case, both X and Y must have\n        the same associated matrix.\n\n        Only rows (resp. columns) of M starting from ly (resp. lx) are\n        computed, where ly (resp. lx) is the number of leading columns of Y\n        (resp. X).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_89dot(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcBVObject *__pyx_v_Y = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("dot (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Y,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Y)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "dot") < 0)) __PYX_ERR(13, 841, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_Y = ((struct PySlepcBVObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("dot", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 841, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.dot", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Y), __pyx_ptype_8slepc4py_5SLEPc_BV, 0, "Y", 0))) __PYX_ERR(13, 841, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_88dot(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_Y);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_88dot(struct PySlepcBVObject *__pyx_v_self, struct PySlepcBVObject *__pyx_v_Y) {
  struct PySlepcBVObject *__pyx_v_X = 0;
  PetscInt __pyx_v_ky;
  PetscInt __pyx_v_kx;
  struct PyPetscMatObject *__pyx_v_M = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("dot", 0);

  /* "SLEPc/BV.pyx":872
 *         (resp. X).
 *         """
 *         cdef BV X = self             # <<<<<<<<<<<<<<
 *         cdef PetscInt ky=0, kx=0
 *         CHKERR( BVGetActiveColumns(Y.bv, NULL, &ky) )
 */
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_v_X = __pyx_v_self;

  /* "SLEPc/BV.pyx":873
 *         """
 *         cdef BV X = self
 *         cdef PetscInt ky=0, kx=0             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetActiveColumns(Y.bv, NULL, &ky) )
 *         CHKERR( BVGetActiveColumns(X.bv, NULL, &kx) )
 */
  __pyx_v_ky = 0;
  __pyx_v_kx = 0;

  /* "SLEPc/BV.pyx":874
 *         cdef BV X = self
 *         cdef PetscInt ky=0, kx=0
 *         CHKERR( BVGetActiveColumns(Y.bv, NULL, &ky) )             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetActiveColumns(X.bv, NULL, &kx) )
 *         cdef Mat M = Mat().createDense((ky, kx), comm=COMM_SELF).setUp()
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetActiveColumns(__pyx_v_Y->bv, NULL, (&__pyx_v_ky))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 874, __pyx_L1_error)

  /* "SLEPc/BV.pyx":875
 *         cdef PetscInt ky=0, kx=0
 *         CHKERR( BVGetActiveColumns(Y.bv, NULL, &ky) )
 *         CHKERR( BVGetActiveColumns(X.bv, NULL, &kx) )             # <<<<<<<<<<<<<<
 *         cdef Mat M = Mat().createDense((ky, kx), comm=COMM_SELF).setUp()
 *         CHKERR( BVDot(X.bv, Y.bv, M.mat) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetActiveColumns(__pyx_v_X->bv, NULL, (&__pyx_v_kx))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 875, __pyx_L1_error)

  /* "SLEPc/BV.pyx":876
 *         CHKERR( BVGetActiveColumns(Y.bv, NULL, &ky) )
 *         CHKERR( BVGetActiveColumns(X.bv, NULL, &kx) )
 *         cdef Mat M = Mat().createDense((ky, kx), comm=COMM_SELF).setUp()             # <<<<<<<<<<<<<<
 *         CHKERR( BVDot(X.bv, Y.bv, M.mat) )
 *         return M
 */
  __pyx_t_3 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_createDense); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyInt_From_PetscInt(__pyx_v_ky); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyInt_From_PetscInt(__pyx_v_kx); if (unlikely(!__pyx_t_5)) __PYX_ERR(13, 876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(13, 876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5);
  __pyx_t_3 = 0;
  __pyx_t_5 = 0;
  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(13, 876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6);
  __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(13, 876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_COMM_SELF); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_comm, __pyx_t_3) < 0) __PYX_ERR(13, 876, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_setUp); if (unlikely(!__pyx_t_6)) __PYX_ERR(13, 876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_6);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_6, function);
    }
  }
  __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 876, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_8petsc4py_5PETSc_Mat))))) __PYX_ERR(13, 876, __pyx_L1_error)
  __pyx_v_M = ((struct PyPetscMatObject *)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/BV.pyx":877
 *         CHKERR( BVGetActiveColumns(X.bv, NULL, &kx) )
 *         cdef Mat M = Mat().createDense((ky, kx), comm=COMM_SELF).setUp()
 *         CHKERR( BVDot(X.bv, Y.bv, M.mat) )             # <<<<<<<<<<<<<<
 *         return M
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVDot(__pyx_v_X->bv, __pyx_v_Y->bv, __pyx_v_M->mat)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 877, __pyx_L1_error)

  /* "SLEPc/BV.pyx":878
 *         cdef Mat M = Mat().createDense((ky, kx), comm=COMM_SELF).setUp()
 *         CHKERR( BVDot(X.bv, Y.bv, M.mat) )
 *         return M             # <<<<<<<<<<<<<<
 * 
 *     def matProject(self, Mat A or None, BV Y):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_M));
  __pyx_r = ((PyObject *)__pyx_v_M);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":841
 *         CHKERR( BVRestoreMat(self.bv, &A.mat) )
 * 
 *     def dot(self, BV Y):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the 'block-dot' product of two basis vectors objects.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.dot", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_X);
  __Pyx_XDECREF((PyObject *)__pyx_v_M);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":880
 *         return M
 * 
 *     def matProject(self, Mat A or None, BV Y):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the projection of a matrix onto a subspace.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_91matProject(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_90matProject[] = "BV.matProject(self, Mat A, BV Y)\n\n        Computes the projection of a matrix onto a subspace.\n\n        M = Y^H A X\n\n        Parameters\n        ----------\n        A: Mat or None\n            Matrix to be projected.\n        Y: BV\n            Left basis vectors, can be the same as self, giving M = X^H A X.\n\n        Returns\n        -------\n        M: Mat\n            Projection of the matrix A onto the subspace.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_91matProject(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  struct PySlepcBVObject *__pyx_v_Y = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("matProject (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_A,&__pyx_n_s_Y,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_A)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Y)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("matProject", 1, 2, 2, 1); __PYX_ERR(13, 880, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "matProject") < 0)) __PYX_ERR(13, 880, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_A = ((struct PyPetscMatObject *)values[0]);
    __pyx_v_Y = ((struct PySlepcBVObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("matProject", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 880, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.matProject", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_A), __pyx_ptype_8petsc4py_5PETSc_Mat, 1, "A", 0))) __PYX_ERR(13, 880, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Y), __pyx_ptype_8slepc4py_5SLEPc_BV, 0, "Y", 0))) __PYX_ERR(13, 880, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_90matProject(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_A, __pyx_v_Y);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_90matProject(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, struct PySlepcBVObject *__pyx_v_Y) {
  struct PySlepcBVObject *__pyx_v_X = 0;
  PetscInt __pyx_v_kx;
  PetscInt __pyx_v_ky;
  Mat __pyx_v_Amat;
  struct PyPetscMatObject *__pyx_v_M = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  Mat __pyx_t_2;
  int __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("matProject", 0);

  /* "SLEPc/BV.pyx":898
 *             Projection of the matrix A onto the subspace.
 *         """
 *         cdef BV X = self             # <<<<<<<<<<<<<<
 *         cdef PetscInt  kx=0, ky=0
 *         CHKERR( BVGetActiveColumns(X.bv, NULL, &kx) )
 */
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_v_X = __pyx_v_self;

  /* "SLEPc/BV.pyx":899
 *         """
 *         cdef BV X = self
 *         cdef PetscInt  kx=0, ky=0             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetActiveColumns(X.bv, NULL, &kx) )
 *         CHKERR( BVGetActiveColumns(Y.bv, NULL, &ky) )
 */
  __pyx_v_kx = 0;
  __pyx_v_ky = 0;

  /* "SLEPc/BV.pyx":900
 *         cdef BV X = self
 *         cdef PetscInt  kx=0, ky=0
 *         CHKERR( BVGetActiveColumns(X.bv, NULL, &kx) )             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetActiveColumns(Y.bv, NULL, &ky) )
 *         cdef PetscMat Amat = <PetscMat>NULL if A is None else A.mat
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetActiveColumns(__pyx_v_X->bv, NULL, (&__pyx_v_kx))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 900, __pyx_L1_error)

  /* "SLEPc/BV.pyx":901
 *         cdef PetscInt  kx=0, ky=0
 *         CHKERR( BVGetActiveColumns(X.bv, NULL, &kx) )
 *         CHKERR( BVGetActiveColumns(Y.bv, NULL, &ky) )             # <<<<<<<<<<<<<<
 *         cdef PetscMat Amat = <PetscMat>NULL if A is None else A.mat
 *         cdef Mat M = Mat().createDense((ky, kx), comm=COMM_SELF).setUp()
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetActiveColumns(__pyx_v_Y->bv, NULL, (&__pyx_v_ky))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 901, __pyx_L1_error)

  /* "SLEPc/BV.pyx":902
 *         CHKERR( BVGetActiveColumns(X.bv, NULL, &kx) )
 *         CHKERR( BVGetActiveColumns(Y.bv, NULL, &ky) )
 *         cdef PetscMat Amat = <PetscMat>NULL if A is None else A.mat             # <<<<<<<<<<<<<<
 *         cdef Mat M = Mat().createDense((ky, kx), comm=COMM_SELF).setUp()
 *         CHKERR( BVMatProject(X.bv, Amat, Y.bv, M.mat) )
 */
  __pyx_t_3 = (((PyObject *)__pyx_v_A) == Py_None);
  if ((__pyx_t_3 != 0)) {
    __pyx_t_2 = ((Mat)NULL);
  } else {
    __pyx_t_2 = __pyx_v_A->mat;
  }
  __pyx_v_Amat = __pyx_t_2;

  /* "SLEPc/BV.pyx":903
 *         CHKERR( BVGetActiveColumns(Y.bv, NULL, &ky) )
 *         cdef PetscMat Amat = <PetscMat>NULL if A is None else A.mat
 *         cdef Mat M = Mat().createDense((ky, kx), comm=COMM_SELF).setUp()             # <<<<<<<<<<<<<<
 *         CHKERR( BVMatProject(X.bv, Amat, Y.bv, M.mat) )
 *         return M
 */
  __pyx_t_5 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_5)) __PYX_ERR(13, 903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_createDense); if (unlikely(!__pyx_t_6)) __PYX_ERR(13, 903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyInt_From_PetscInt(__pyx_v_ky); if (unlikely(!__pyx_t_5)) __PYX_ERR(13, 903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = __Pyx_PyInt_From_PetscInt(__pyx_v_kx); if (unlikely(!__pyx_t_7)) __PYX_ERR(13, 903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(13, 903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_7);
  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7);
  __pyx_t_5 = 0;
  __pyx_t_7 = 0;
  __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(13, 903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GIVEREF(__pyx_t_8);
  PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8);
  __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(13, 903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_COMM_SELF); if (unlikely(!__pyx_t_5)) __PYX_ERR(13, 903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_comm, __pyx_t_5) < 0) __PYX_ERR(13, 903, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(13, 903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_setUp); if (unlikely(!__pyx_t_8)) __PYX_ERR(13, 903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_8);
    if (likely(__pyx_t_5)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_8, function);
    }
  }
  __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_8petsc4py_5PETSc_Mat))))) __PYX_ERR(13, 903, __pyx_L1_error)
  __pyx_v_M = ((struct PyPetscMatObject *)__pyx_t_4);
  __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":904
 *         cdef PetscMat Amat = <PetscMat>NULL if A is None else A.mat
 *         cdef Mat M = Mat().createDense((ky, kx), comm=COMM_SELF).setUp()
 *         CHKERR( BVMatProject(X.bv, Amat, Y.bv, M.mat) )             # <<<<<<<<<<<<<<
 *         return M
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVMatProject(__pyx_v_X->bv, __pyx_v_Amat, __pyx_v_Y->bv, __pyx_v_M->mat)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 904, __pyx_L1_error)

  /* "SLEPc/BV.pyx":905
 *         cdef Mat M = Mat().createDense((ky, kx), comm=COMM_SELF).setUp()
 *         CHKERR( BVMatProject(X.bv, Amat, Y.bv, M.mat) )
 *         return M             # <<<<<<<<<<<<<<
 * 
 *     def matMult(self, Mat A, BV Y=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_M));
  __pyx_r = ((PyObject *)__pyx_v_M);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":880
 *         return M
 * 
 *     def matProject(self, Mat A or None, BV Y):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the projection of a matrix onto a subspace.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.matProject", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_X);
  __Pyx_XDECREF((PyObject *)__pyx_v_M);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":907
 *         return M
 * 
 *     def matMult(self, Mat A, BV Y=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the matrix-vector product for each column, Y = A*V.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_93matMult(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_92matMult[] = "BV.matMult(self, Mat A, BV Y=None)\n\n        Computes the matrix-vector product for each column, Y = A*V.\n\n        Parameters\n        ----------\n        A: Mat\n            The matrix.\n\n        Returns\n        -------\n        Y: BV\n            The result.\n\n        Notes\n        -----\n        Only active columns (excluding the leading ones) are processed.\n\n        It is possible to choose whether the computation is done column by column\n        or using dense matrices using the options database keys:\n\n            -bv_matmult_vecs\n            -bv_matmult_mat\n\n        The default is bv_matmult_mat.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_93matMult(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  struct PySlepcBVObject *__pyx_v_Y = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("matMult (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_A,&__pyx_n_s_Y,0};
    PyObject* values[2] = {0,0};
    values[1] = (PyObject *)((struct PySlepcBVObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_A)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Y);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "matMult") < 0)) __PYX_ERR(13, 907, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_A = ((struct PyPetscMatObject *)values[0]);
    __pyx_v_Y = ((struct PySlepcBVObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("matMult", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 907, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.matMult", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_A), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "A", 0))) __PYX_ERR(13, 907, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Y), __pyx_ptype_8slepc4py_5SLEPc_BV, 1, "Y", 0))) __PYX_ERR(13, 907, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_92matMult(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_A, __pyx_v_Y);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_92matMult(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, struct PySlepcBVObject *__pyx_v_Y) {
  MPI_Comm __pyx_v_comm;
  const char* __pyx_v_bv_type;
  PetscInt __pyx_v_n;
  PetscInt __pyx_v_N;
  PetscInt __pyx_v_m;
  BVOrthogType __pyx_v_val1;
  BVOrthogRefineType __pyx_v_val2;
  BVOrthogBlockType __pyx_v_val3;
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("matMult", 0);
  __Pyx_INCREF((PyObject *)__pyx_v_Y);

  /* "SLEPc/BV.pyx":933
 *         The default is bv_matmult_mat.
 *         """
 *         cdef MPI_Comm comm = PetscObjectComm(<PetscObject>self.bv)             # <<<<<<<<<<<<<<
 *         cdef SlepcBVType bv_type = NULL
 *         cdef PetscInt n=0, N=0, m=0
 */
  __pyx_v_comm = PetscObjectComm(((PetscObject)__pyx_v_self->bv));

  /* "SLEPc/BV.pyx":934
 *         """
 *         cdef MPI_Comm comm = PetscObjectComm(<PetscObject>self.bv)
 *         cdef SlepcBVType bv_type = NULL             # <<<<<<<<<<<<<<
 *         cdef PetscInt n=0, N=0, m=0
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS
 */
  __pyx_v_bv_type = NULL;

  /* "SLEPc/BV.pyx":935
 *         cdef MPI_Comm comm = PetscObjectComm(<PetscObject>self.bv)
 *         cdef SlepcBVType bv_type = NULL
 *         cdef PetscInt n=0, N=0, m=0             # <<<<<<<<<<<<<<
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED
 */
  __pyx_v_n = 0;
  __pyx_v_N = 0;
  __pyx_v_m = 0;

  /* "SLEPc/BV.pyx":936
 *         cdef SlepcBVType bv_type = NULL
 *         cdef PetscInt n=0, N=0, m=0
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS             # <<<<<<<<<<<<<<
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 */
  __pyx_v_val1 = BV_ORTHOG_CGS;

  /* "SLEPc/BV.pyx":937
 *         cdef PetscInt n=0, N=0, m=0
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED             # <<<<<<<<<<<<<<
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 *         cdef PetscReal rval = PETSC_DEFAULT
 */
  __pyx_v_val2 = BV_ORTHOG_REFINE_IFNEEDED;

  /* "SLEPc/BV.pyx":938
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         if Y is None: Y = BV()
 */
  __pyx_v_val3 = BV_ORTHOG_BLOCK_GS;

  /* "SLEPc/BV.pyx":939
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 *         cdef PetscReal rval = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if Y is None: Y = BV()
 *         if Y.bv == NULL:
 */
  __pyx_v_rval = PETSC_DEFAULT;

  /* "SLEPc/BV.pyx":940
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         if Y is None: Y = BV()             # <<<<<<<<<<<<<<
 *         if Y.bv == NULL:
 *             CHKERR( BVGetType(self.bv, &bv_type) )
 */
  __pyx_t_1 = (((PyObject *)__pyx_v_Y) == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV)); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 940, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_Y, ((struct PySlepcBVObject *)__pyx_t_3));
    __pyx_t_3 = 0;
  }

  /* "SLEPc/BV.pyx":941
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         if Y is None: Y = BV()
 *         if Y.bv == NULL:             # <<<<<<<<<<<<<<
 *             CHKERR( BVGetType(self.bv, &bv_type) )
 *             CHKERR( MatGetLocalSize(A.mat, &n, NULL) )
 */
  __pyx_t_2 = ((__pyx_v_Y->bv == NULL) != 0);
  if (__pyx_t_2) {

    /* "SLEPc/BV.pyx":942
 *         if Y is None: Y = BV()
 *         if Y.bv == NULL:
 *             CHKERR( BVGetType(self.bv, &bv_type) )             # <<<<<<<<<<<<<<
 *             CHKERR( MatGetLocalSize(A.mat, &n, NULL) )
 *             CHKERR( MatGetSize(A.mat, &N, NULL) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetType(__pyx_v_self->bv, (&__pyx_v_bv_type))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 942, __pyx_L1_error)

    /* "SLEPc/BV.pyx":943
 *         if Y.bv == NULL:
 *             CHKERR( BVGetType(self.bv, &bv_type) )
 *             CHKERR( MatGetLocalSize(A.mat, &n, NULL) )             # <<<<<<<<<<<<<<
 *             CHKERR( MatGetSize(A.mat, &N, NULL) )
 *             CHKERR( BVGetSizes(self.bv, NULL, NULL, &m) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MatGetLocalSize(__pyx_v_A->mat, (&__pyx_v_n), NULL)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 943, __pyx_L1_error)

    /* "SLEPc/BV.pyx":944
 *             CHKERR( BVGetType(self.bv, &bv_type) )
 *             CHKERR( MatGetLocalSize(A.mat, &n, NULL) )
 *             CHKERR( MatGetSize(A.mat, &N, NULL) )             # <<<<<<<<<<<<<<
 *             CHKERR( BVGetSizes(self.bv, NULL, NULL, &m) )
 *             CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MatGetSize(__pyx_v_A->mat, (&__pyx_v_N), NULL)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 944, __pyx_L1_error)

    /* "SLEPc/BV.pyx":945
 *             CHKERR( MatGetLocalSize(A.mat, &n, NULL) )
 *             CHKERR( MatGetSize(A.mat, &N, NULL) )
 *             CHKERR( BVGetSizes(self.bv, NULL, NULL, &m) )             # <<<<<<<<<<<<<<
 *             CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 *             CHKERR( BVCreate(comm, &Y.bv) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetSizes(__pyx_v_self->bv, NULL, NULL, (&__pyx_v_m))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 945, __pyx_L1_error)

    /* "SLEPc/BV.pyx":946
 *             CHKERR( MatGetSize(A.mat, &N, NULL) )
 *             CHKERR( BVGetSizes(self.bv, NULL, NULL, &m) )
 *             CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )             # <<<<<<<<<<<<<<
 *             CHKERR( BVCreate(comm, &Y.bv) )
 *             CHKERR( BVSetType(Y.bv, bv_type) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetOrthogonalization(__pyx_v_self->bv, (&__pyx_v_val1), (&__pyx_v_val2), (&__pyx_v_rval), (&__pyx_v_val3))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 946, __pyx_L1_error)

    /* "SLEPc/BV.pyx":947
 *             CHKERR( BVGetSizes(self.bv, NULL, NULL, &m) )
 *             CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 *             CHKERR( BVCreate(comm, &Y.bv) )             # <<<<<<<<<<<<<<
 *             CHKERR( BVSetType(Y.bv, bv_type) )
 *             CHKERR( BVSetSizes(Y.bv, n, N, m) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVCreate(__pyx_v_comm, (&__pyx_v_Y->bv))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 947, __pyx_L1_error)

    /* "SLEPc/BV.pyx":948
 *             CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 *             CHKERR( BVCreate(comm, &Y.bv) )
 *             CHKERR( BVSetType(Y.bv, bv_type) )             # <<<<<<<<<<<<<<
 *             CHKERR( BVSetSizes(Y.bv, n, N, m) )
 *             CHKERR( BVSetOrthogonalization(Y.bv, val1, val2, rval, val3) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetType(__pyx_v_Y->bv, __pyx_v_bv_type)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 948, __pyx_L1_error)

    /* "SLEPc/BV.pyx":949
 *             CHKERR( BVCreate(comm, &Y.bv) )
 *             CHKERR( BVSetType(Y.bv, bv_type) )
 *             CHKERR( BVSetSizes(Y.bv, n, N, m) )             # <<<<<<<<<<<<<<
 *             CHKERR( BVSetOrthogonalization(Y.bv, val1, val2, rval, val3) )
 *         CHKERR( BVMatMult(self.bv, A.mat, Y.bv) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetSizes(__pyx_v_Y->bv, __pyx_v_n, __pyx_v_N, __pyx_v_m)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 949, __pyx_L1_error)

    /* "SLEPc/BV.pyx":950
 *             CHKERR( BVSetType(Y.bv, bv_type) )
 *             CHKERR( BVSetSizes(Y.bv, n, N, m) )
 *             CHKERR( BVSetOrthogonalization(Y.bv, val1, val2, rval, val3) )             # <<<<<<<<<<<<<<
 *         CHKERR( BVMatMult(self.bv, A.mat, Y.bv) )
 *         return Y
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetOrthogonalization(__pyx_v_Y->bv, __pyx_v_val1, __pyx_v_val2, __pyx_v_rval, __pyx_v_val3)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 950, __pyx_L1_error)

    /* "SLEPc/BV.pyx":941
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         if Y is None: Y = BV()
 *         if Y.bv == NULL:             # <<<<<<<<<<<<<<
 *             CHKERR( BVGetType(self.bv, &bv_type) )
 *             CHKERR( MatGetLocalSize(A.mat, &n, NULL) )
 */
  }

  /* "SLEPc/BV.pyx":951
 *             CHKERR( BVSetSizes(Y.bv, n, N, m) )
 *             CHKERR( BVSetOrthogonalization(Y.bv, val1, val2, rval, val3) )
 *         CHKERR( BVMatMult(self.bv, A.mat, Y.bv) )             # <<<<<<<<<<<<<<
 *         return Y
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVMatMult(__pyx_v_self->bv, __pyx_v_A->mat, __pyx_v_Y->bv)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 951, __pyx_L1_error)

  /* "SLEPc/BV.pyx":952
 *             CHKERR( BVSetOrthogonalization(Y.bv, val1, val2, rval, val3) )
 *         CHKERR( BVMatMult(self.bv, A.mat, Y.bv) )
 *         return Y             # <<<<<<<<<<<<<<
 * 
 *     def matMultHermitianTranspose(self, Mat A, BV Y=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_Y));
  __pyx_r = ((PyObject *)__pyx_v_Y);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":907
 *         return M
 * 
 *     def matMult(self, Mat A, BV Y=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the matrix-vector product for each column, Y = A*V.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.matMult", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_Y);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":954
 *         return Y
 * 
 *     def matMultHermitianTranspose(self, Mat A, BV Y=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the matrix-vector product with the conjugate transpose of a
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_95matMultHermitianTranspose(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_94matMultHermitianTranspose[] = "BV.matMultHermitianTranspose(self, Mat A, BV Y=None)\n\n        Computes the matrix-vector product with the conjugate transpose of a\n        matrix for each column, Y=A^H*V.\n\n        Parameters\n        ----------\n        A: Mat\n            The matrix.\n\n        Returns\n        -------\n        Y: BV\n            The result.\n\n        Notes\n        -----\n        Only active columns (excluding the leading ones) are processed.\n\n        As opoosed to matMult(), this operation is always done by column by\n        column, with a sequence of calls to MatMultHermitianTranspose().\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_95matMultHermitianTranspose(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  struct PySlepcBVObject *__pyx_v_Y = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("matMultHermitianTranspose (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_A,&__pyx_n_s_Y,0};
    PyObject* values[2] = {0,0};
    values[1] = (PyObject *)((struct PySlepcBVObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_A)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Y);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "matMultHermitianTranspose") < 0)) __PYX_ERR(13, 954, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_A = ((struct PyPetscMatObject *)values[0]);
    __pyx_v_Y = ((struct PySlepcBVObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("matMultHermitianTranspose", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 954, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.matMultHermitianTranspose", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_A), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "A", 0))) __PYX_ERR(13, 954, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Y), __pyx_ptype_8slepc4py_5SLEPc_BV, 1, "Y", 0))) __PYX_ERR(13, 954, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_94matMultHermitianTranspose(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_A, __pyx_v_Y);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_94matMultHermitianTranspose(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, struct PySlepcBVObject *__pyx_v_Y) {
  MPI_Comm __pyx_v_comm;
  const char* __pyx_v_bv_type;
  PetscInt __pyx_v_n;
  PetscInt __pyx_v_N;
  PetscInt __pyx_v_m;
  BVOrthogType __pyx_v_val1;
  BVOrthogRefineType __pyx_v_val2;
  BVOrthogBlockType __pyx_v_val3;
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("matMultHermitianTranspose", 0);
  __Pyx_INCREF((PyObject *)__pyx_v_Y);

  /* "SLEPc/BV.pyx":976
 *         column, with a sequence of calls to MatMultHermitianTranspose().
 *         """
 *         cdef MPI_Comm comm = PetscObjectComm(<PetscObject>self.bv)             # <<<<<<<<<<<<<<
 *         cdef SlepcBVType bv_type = NULL
 *         cdef PetscInt n=0, N=0, m=0
 */
  __pyx_v_comm = PetscObjectComm(((PetscObject)__pyx_v_self->bv));

  /* "SLEPc/BV.pyx":977
 *         """
 *         cdef MPI_Comm comm = PetscObjectComm(<PetscObject>self.bv)
 *         cdef SlepcBVType bv_type = NULL             # <<<<<<<<<<<<<<
 *         cdef PetscInt n=0, N=0, m=0
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS
 */
  __pyx_v_bv_type = NULL;

  /* "SLEPc/BV.pyx":978
 *         cdef MPI_Comm comm = PetscObjectComm(<PetscObject>self.bv)
 *         cdef SlepcBVType bv_type = NULL
 *         cdef PetscInt n=0, N=0, m=0             # <<<<<<<<<<<<<<
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED
 */
  __pyx_v_n = 0;
  __pyx_v_N = 0;
  __pyx_v_m = 0;

  /* "SLEPc/BV.pyx":979
 *         cdef SlepcBVType bv_type = NULL
 *         cdef PetscInt n=0, N=0, m=0
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS             # <<<<<<<<<<<<<<
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 */
  __pyx_v_val1 = BV_ORTHOG_CGS;

  /* "SLEPc/BV.pyx":980
 *         cdef PetscInt n=0, N=0, m=0
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED             # <<<<<<<<<<<<<<
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 *         cdef PetscReal rval = PETSC_DEFAULT
 */
  __pyx_v_val2 = BV_ORTHOG_REFINE_IFNEEDED;

  /* "SLEPc/BV.pyx":981
 *         cdef SlepcBVOrthogType val1 = BV_ORTHOG_CGS
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         if Y is None: Y = BV()
 */
  __pyx_v_val3 = BV_ORTHOG_BLOCK_GS;

  /* "SLEPc/BV.pyx":982
 *         cdef SlepcBVOrthogRefineType val2 = BV_ORTHOG_REFINE_IFNEEDED
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 *         cdef PetscReal rval = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if Y is None: Y = BV()
 *         if Y.bv == NULL:
 */
  __pyx_v_rval = PETSC_DEFAULT;

  /* "SLEPc/BV.pyx":983
 *         cdef SlepcBVOrthogBlockType val3 = BV_ORTHOG_BLOCK_GS
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         if Y is None: Y = BV()             # <<<<<<<<<<<<<<
 *         if Y.bv == NULL:
 *             CHKERR( BVGetType(self.bv, &bv_type) )
 */
  __pyx_t_1 = (((PyObject *)__pyx_v_Y) == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV)); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 983, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_Y, ((struct PySlepcBVObject *)__pyx_t_3));
    __pyx_t_3 = 0;
  }

  /* "SLEPc/BV.pyx":984
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         if Y is None: Y = BV()
 *         if Y.bv == NULL:             # <<<<<<<<<<<<<<
 *             CHKERR( BVGetType(self.bv, &bv_type) )
 *             CHKERR( MatGetLocalSize(A.mat, NULL, &n) )
 */
  __pyx_t_2 = ((__pyx_v_Y->bv == NULL) != 0);
  if (__pyx_t_2) {

    /* "SLEPc/BV.pyx":985
 *         if Y is None: Y = BV()
 *         if Y.bv == NULL:
 *             CHKERR( BVGetType(self.bv, &bv_type) )             # <<<<<<<<<<<<<<
 *             CHKERR( MatGetLocalSize(A.mat, NULL, &n) )
 *             CHKERR( MatGetSize(A.mat, NULL, &N) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetType(__pyx_v_self->bv, (&__pyx_v_bv_type))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 985, __pyx_L1_error)

    /* "SLEPc/BV.pyx":986
 *         if Y.bv == NULL:
 *             CHKERR( BVGetType(self.bv, &bv_type) )
 *             CHKERR( MatGetLocalSize(A.mat, NULL, &n) )             # <<<<<<<<<<<<<<
 *             CHKERR( MatGetSize(A.mat, NULL, &N) )
 *             CHKERR( BVGetSizes(self.bv, NULL, NULL, &m) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MatGetLocalSize(__pyx_v_A->mat, NULL, (&__pyx_v_n))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 986, __pyx_L1_error)

    /* "SLEPc/BV.pyx":987
 *             CHKERR( BVGetType(self.bv, &bv_type) )
 *             CHKERR( MatGetLocalSize(A.mat, NULL, &n) )
 *             CHKERR( MatGetSize(A.mat, NULL, &N) )             # <<<<<<<<<<<<<<
 *             CHKERR( BVGetSizes(self.bv, NULL, NULL, &m) )
 *             CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MatGetSize(__pyx_v_A->mat, NULL, (&__pyx_v_N))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 987, __pyx_L1_error)

    /* "SLEPc/BV.pyx":988
 *             CHKERR( MatGetLocalSize(A.mat, NULL, &n) )
 *             CHKERR( MatGetSize(A.mat, NULL, &N) )
 *             CHKERR( BVGetSizes(self.bv, NULL, NULL, &m) )             # <<<<<<<<<<<<<<
 *             CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 *             CHKERR( BVCreate(comm, &Y.bv) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetSizes(__pyx_v_self->bv, NULL, NULL, (&__pyx_v_m))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 988, __pyx_L1_error)

    /* "SLEPc/BV.pyx":989
 *             CHKERR( MatGetSize(A.mat, NULL, &N) )
 *             CHKERR( BVGetSizes(self.bv, NULL, NULL, &m) )
 *             CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )             # <<<<<<<<<<<<<<
 *             CHKERR( BVCreate(comm, &Y.bv) )
 *             CHKERR( BVSetType(Y.bv, bv_type) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetOrthogonalization(__pyx_v_self->bv, (&__pyx_v_val1), (&__pyx_v_val2), (&__pyx_v_rval), (&__pyx_v_val3))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 989, __pyx_L1_error)

    /* "SLEPc/BV.pyx":990
 *             CHKERR( BVGetSizes(self.bv, NULL, NULL, &m) )
 *             CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 *             CHKERR( BVCreate(comm, &Y.bv) )             # <<<<<<<<<<<<<<
 *             CHKERR( BVSetType(Y.bv, bv_type) )
 *             CHKERR( BVSetSizes(Y.bv, n, N, m) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVCreate(__pyx_v_comm, (&__pyx_v_Y->bv))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 990, __pyx_L1_error)

    /* "SLEPc/BV.pyx":991
 *             CHKERR( BVGetOrthogonalization(self.bv, &val1, &val2, &rval, &val3) )
 *             CHKERR( BVCreate(comm, &Y.bv) )
 *             CHKERR( BVSetType(Y.bv, bv_type) )             # <<<<<<<<<<<<<<
 *             CHKERR( BVSetSizes(Y.bv, n, N, m) )
 *             CHKERR( BVSetOrthogonalization(Y.bv, val1, val2, rval, val3) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetType(__pyx_v_Y->bv, __pyx_v_bv_type)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 991, __pyx_L1_error)

    /* "SLEPc/BV.pyx":992
 *             CHKERR( BVCreate(comm, &Y.bv) )
 *             CHKERR( BVSetType(Y.bv, bv_type) )
 *             CHKERR( BVSetSizes(Y.bv, n, N, m) )             # <<<<<<<<<<<<<<
 *             CHKERR( BVSetOrthogonalization(Y.bv, val1, val2, rval, val3) )
 *         CHKERR( BVMatMultHermitianTranspose(self.bv, A.mat, Y.bv) )
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetSizes(__pyx_v_Y->bv, __pyx_v_n, __pyx_v_N, __pyx_v_m)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 992, __pyx_L1_error)

    /* "SLEPc/BV.pyx":993
 *             CHKERR( BVSetType(Y.bv, bv_type) )
 *             CHKERR( BVSetSizes(Y.bv, n, N, m) )
 *             CHKERR( BVSetOrthogonalization(Y.bv, val1, val2, rval, val3) )             # <<<<<<<<<<<<<<
 *         CHKERR( BVMatMultHermitianTranspose(self.bv, A.mat, Y.bv) )
 *         return Y
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetOrthogonalization(__pyx_v_Y->bv, __pyx_v_val1, __pyx_v_val2, __pyx_v_rval, __pyx_v_val3)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 993, __pyx_L1_error)

    /* "SLEPc/BV.pyx":984
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         if Y is None: Y = BV()
 *         if Y.bv == NULL:             # <<<<<<<<<<<<<<
 *             CHKERR( BVGetType(self.bv, &bv_type) )
 *             CHKERR( MatGetLocalSize(A.mat, NULL, &n) )
 */
  }

  /* "SLEPc/BV.pyx":994
 *             CHKERR( BVSetSizes(Y.bv, n, N, m) )
 *             CHKERR( BVSetOrthogonalization(Y.bv, val1, val2, rval, val3) )
 *         CHKERR( BVMatMultHermitianTranspose(self.bv, A.mat, Y.bv) )             # <<<<<<<<<<<<<<
 *         return Y
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVMatMultHermitianTranspose(__pyx_v_self->bv, __pyx_v_A->mat, __pyx_v_Y->bv)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 994, __pyx_L1_error)

  /* "SLEPc/BV.pyx":995
 *             CHKERR( BVSetOrthogonalization(Y.bv, val1, val2, rval, val3) )
 *         CHKERR( BVMatMultHermitianTranspose(self.bv, A.mat, Y.bv) )
 *         return Y             # <<<<<<<<<<<<<<
 * 
 *     def matMultColumn(self, Mat A, j):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_Y));
  __pyx_r = ((PyObject *)__pyx_v_Y);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":954
 *         return Y
 * 
 *     def matMultHermitianTranspose(self, Mat A, BV Y=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the matrix-vector product with the conjugate transpose of a
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.matMultHermitianTranspose", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_Y);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":997
 *         return Y
 * 
 *     def matMultColumn(self, Mat A, j):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the matrix-vector product for a specified column, storing
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_97matMultColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_96matMultColumn[] = "BV.matMultColumn(self, Mat A, j)\n\n        Computes the matrix-vector product for a specified column, storing\n        the result in the next column: v_{j+1}=A*v_j.\n\n        Parameters\n        ----------\n        A: Mat\n            The matrix.\n        j: int\n            Index of column.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_97matMultColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  PyObject *__pyx_v_j = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("matMultColumn (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_A,&__pyx_n_s_j,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_A)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("matMultColumn", 1, 2, 2, 1); __PYX_ERR(13, 997, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "matMultColumn") < 0)) __PYX_ERR(13, 997, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_A = ((struct PyPetscMatObject *)values[0]);
    __pyx_v_j = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("matMultColumn", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 997, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.matMultColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_A), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "A", 0))) __PYX_ERR(13, 997, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_96matMultColumn(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_A, __pyx_v_j);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_96matMultColumn(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, PyObject *__pyx_v_j) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("matMultColumn", 0);

  /* "SLEPc/BV.pyx":1009
 *             Index of column.
 *         """
 *         cdef PetscInt ival = asInt(j)             # <<<<<<<<<<<<<<
 *         CHKERR( BVMatMultColumn(self.bv, A.mat, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_j); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 1009, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/BV.pyx":1010
 *         """
 *         cdef PetscInt ival = asInt(j)
 *         CHKERR( BVMatMultColumn(self.bv, A.mat, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def matMultTransposeColumn(self, Mat A, j):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVMatMultColumn(__pyx_v_self->bv, __pyx_v_A->mat, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 1010, __pyx_L1_error)

  /* "SLEPc/BV.pyx":997
 *         return Y
 * 
 *     def matMultColumn(self, Mat A, j):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the matrix-vector product for a specified column, storing
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.matMultColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1012
 *         CHKERR( BVMatMultColumn(self.bv, A.mat, ival) )
 * 
 *     def matMultTransposeColumn(self, Mat A, j):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the transpose matrix-vector product for a specified column,
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_99matMultTransposeColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_98matMultTransposeColumn[] = "BV.matMultTransposeColumn(self, Mat A, j)\n\n        Computes the transpose matrix-vector product for a specified column,\n        storing the result in the next column: v_{j+1}=A^T*v_j.\n\n        Parameters\n        ----------\n        A: Mat\n            The matrix.\n        j: int\n            Index of column.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_99matMultTransposeColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  PyObject *__pyx_v_j = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("matMultTransposeColumn (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_A,&__pyx_n_s_j,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_A)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("matMultTransposeColumn", 1, 2, 2, 1); __PYX_ERR(13, 1012, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "matMultTransposeColumn") < 0)) __PYX_ERR(13, 1012, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_A = ((struct PyPetscMatObject *)values[0]);
    __pyx_v_j = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("matMultTransposeColumn", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1012, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.matMultTransposeColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_A), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "A", 0))) __PYX_ERR(13, 1012, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_98matMultTransposeColumn(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_A, __pyx_v_j);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_98matMultTransposeColumn(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, PyObject *__pyx_v_j) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("matMultTransposeColumn", 0);

  /* "SLEPc/BV.pyx":1024
 *             Index of column.
 *         """
 *         cdef PetscInt ival = asInt(j)             # <<<<<<<<<<<<<<
 *         CHKERR( BVMatMultTransposeColumn(self.bv, A.mat, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_j); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 1024, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/BV.pyx":1025
 *         """
 *         cdef PetscInt ival = asInt(j)
 *         CHKERR( BVMatMultTransposeColumn(self.bv, A.mat, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def matMultHermitianTransposeColumn(self, Mat A, j):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVMatMultTransposeColumn(__pyx_v_self->bv, __pyx_v_A->mat, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 1025, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1012
 *         CHKERR( BVMatMultColumn(self.bv, A.mat, ival) )
 * 
 *     def matMultTransposeColumn(self, Mat A, j):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the transpose matrix-vector product for a specified column,
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.matMultTransposeColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1027
 *         CHKERR( BVMatMultTransposeColumn(self.bv, A.mat, ival) )
 * 
 *     def matMultHermitianTransposeColumn(self, Mat A, j):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the conjugate-transpose matrix-vector product for a specified column,
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_101matMultHermitianTransposeColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_100matMultHermitianTransposeColumn[] = "BV.matMultHermitianTransposeColumn(self, Mat A, j)\n\n        Computes the conjugate-transpose matrix-vector product for a specified column,\n        storing the result in the next column: v_{j+1}=A^H*v_j.\n\n        Parameters\n        ----------\n        A: Mat\n            The matrix.\n        j: int\n            Index of column.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_101matMultHermitianTransposeColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  PyObject *__pyx_v_j = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("matMultHermitianTransposeColumn (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_A,&__pyx_n_s_j,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_A)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("matMultHermitianTransposeColumn", 1, 2, 2, 1); __PYX_ERR(13, 1027, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "matMultHermitianTransposeColumn") < 0)) __PYX_ERR(13, 1027, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_A = ((struct PyPetscMatObject *)values[0]);
    __pyx_v_j = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("matMultHermitianTransposeColumn", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1027, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.matMultHermitianTransposeColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_A), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "A", 0))) __PYX_ERR(13, 1027, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_100matMultHermitianTransposeColumn(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_A, __pyx_v_j);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_100matMultHermitianTransposeColumn(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, PyObject *__pyx_v_j) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("matMultHermitianTransposeColumn", 0);

  /* "SLEPc/BV.pyx":1039
 *             Index of column.
 *         """
 *         cdef PetscInt ival = asInt(j)             # <<<<<<<<<<<<<<
 *         CHKERR( BVMatMultHermitianTransposeColumn(self.bv, A.mat, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_j); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 1039, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/BV.pyx":1040
 *         """
 *         cdef PetscInt ival = asInt(j)
 *         CHKERR( BVMatMultHermitianTransposeColumn(self.bv, A.mat, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def mult(self, alpha, beta, BV X, Mat Q):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVMatMultHermitianTransposeColumn(__pyx_v_self->bv, __pyx_v_A->mat, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 1040, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1027
 *         CHKERR( BVMatMultTransposeColumn(self.bv, A.mat, ival) )
 * 
 *     def matMultHermitianTransposeColumn(self, Mat A, j):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the conjugate-transpose matrix-vector product for a specified column,
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.matMultHermitianTransposeColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1042
 *         CHKERR( BVMatMultHermitianTransposeColumn(self.bv, A.mat, ival) )
 * 
 *     def mult(self, alpha, beta, BV X, Mat Q):             # <<<<<<<<<<<<<<
 *         """
 *         Computes Y = beta*Y + alpha*X*Q.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_103mult(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_102mult[] = "BV.mult(self, alpha, beta, BV X, Mat Q)\n\n        Computes Y = beta*Y + alpha*X*Q.\n\n        Parameters\n        ----------\n        alpha: scalar\n            Coefficient that multiplies X.\n        beta: scalar\n            Coefficient that multiplies Y.\n        X: BV\n            Input basis vectors.\n        Q: Mat, optional\n            Input matrix, if not given the identity matrix is assumed.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_103mult(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_alpha = 0;
  PyObject *__pyx_v_beta = 0;
  struct PySlepcBVObject *__pyx_v_X = 0;
  struct PyPetscMatObject *__pyx_v_Q = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("mult (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alpha,&__pyx_n_s_beta,&__pyx_n_s_X,&__pyx_n_s_Q,0};
    PyObject* values[4] = {0,0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_beta)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("mult", 1, 4, 4, 1); __PYX_ERR(13, 1042, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_X)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("mult", 1, 4, 4, 2); __PYX_ERR(13, 1042, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Q)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("mult", 1, 4, 4, 3); __PYX_ERR(13, 1042, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "mult") < 0)) __PYX_ERR(13, 1042, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
    }
    __pyx_v_alpha = values[0];
    __pyx_v_beta = values[1];
    __pyx_v_X = ((struct PySlepcBVObject *)values[2]);
    __pyx_v_Q = ((struct PyPetscMatObject *)values[3]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("mult", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1042, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.mult", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_X), __pyx_ptype_8slepc4py_5SLEPc_BV, 0, "X", 0))) __PYX_ERR(13, 1042, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Q), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "Q", 0))) __PYX_ERR(13, 1042, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_102mult(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_alpha, __pyx_v_beta, __pyx_v_X, __pyx_v_Q);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_102mult(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_alpha, PyObject *__pyx_v_beta, struct PySlepcBVObject *__pyx_v_X, struct PyPetscMatObject *__pyx_v_Q) {
  PetscScalar __pyx_v_sval1;
  PetscScalar __pyx_v_sval2;
  Mat __pyx_v_Qmat;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  Mat __pyx_t_2;
  int __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("mult", 0);

  /* "SLEPc/BV.pyx":1057
 *             Input matrix, if not given the identity matrix is assumed.
 *         """
 *         cdef PetscScalar sval1 = asScalar(alpha)             # <<<<<<<<<<<<<<
 *         cdef PetscScalar sval2 = asScalar(beta)
 *         cdef PetscMat Qmat = <PetscMat>NULL if Q is None else Q.mat
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_alpha); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(13, 1057, __pyx_L1_error)
  __pyx_v_sval1 = __pyx_t_1;

  /* "SLEPc/BV.pyx":1058
 *         """
 *         cdef PetscScalar sval1 = asScalar(alpha)
 *         cdef PetscScalar sval2 = asScalar(beta)             # <<<<<<<<<<<<<<
 *         cdef PetscMat Qmat = <PetscMat>NULL if Q is None else Q.mat
 *         CHKERR( BVMult(self.bv, sval1, sval2, X.bv, Qmat) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_beta); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(13, 1058, __pyx_L1_error)
  __pyx_v_sval2 = __pyx_t_1;

  /* "SLEPc/BV.pyx":1059
 *         cdef PetscScalar sval1 = asScalar(alpha)
 *         cdef PetscScalar sval2 = asScalar(beta)
 *         cdef PetscMat Qmat = <PetscMat>NULL if Q is None else Q.mat             # <<<<<<<<<<<<<<
 *         CHKERR( BVMult(self.bv, sval1, sval2, X.bv, Qmat) )
 * 
 */
  __pyx_t_3 = (((PyObject *)__pyx_v_Q) == Py_None);
  if ((__pyx_t_3 != 0)) {
    __pyx_t_2 = ((Mat)NULL);
  } else {
    __pyx_t_2 = __pyx_v_Q->mat;
  }
  __pyx_v_Qmat = __pyx_t_2;

  /* "SLEPc/BV.pyx":1060
 *         cdef PetscScalar sval2 = asScalar(beta)
 *         cdef PetscMat Qmat = <PetscMat>NULL if Q is None else Q.mat
 *         CHKERR( BVMult(self.bv, sval1, sval2, X.bv, Qmat) )             # <<<<<<<<<<<<<<
 * 
 *     def multInPlace(self, Mat Q, s, e):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVMult(__pyx_v_self->bv, __pyx_v_sval1, __pyx_v_sval2, __pyx_v_X->bv, __pyx_v_Qmat)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 1060, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1042
 *         CHKERR( BVMatMultHermitianTransposeColumn(self.bv, A.mat, ival) )
 * 
 *     def mult(self, alpha, beta, BV X, Mat Q):             # <<<<<<<<<<<<<<
 *         """
 *         Computes Y = beta*Y + alpha*X*Q.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.mult", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1062
 *         CHKERR( BVMult(self.bv, sval1, sval2, X.bv, Qmat) )
 * 
 *     def multInPlace(self, Mat Q, s, e):             # <<<<<<<<<<<<<<
 *         """
 *         Update a set of vectors as V(:,s:e-1) = V*Q(:,s:e-1).
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_105multInPlace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_104multInPlace[] = "BV.multInPlace(self, Mat Q, s, e)\n\n        Update a set of vectors as V(:,s:e-1) = V*Q(:,s:e-1).\n\n        Parameters\n        ----------\n        Q: Mat\n           A sequential dense matrix.\n        s: int\n           First column to be overwritten.\n        e: int\n           Last column to be overwritten.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_105multInPlace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_Q = 0;
  PyObject *__pyx_v_s = 0;
  PyObject *__pyx_v_e = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("multInPlace (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Q,&__pyx_n_s_s,&__pyx_n_s_e,0};
    PyObject* values[3] = {0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Q)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_s)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("multInPlace", 1, 3, 3, 1); __PYX_ERR(13, 1062, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_e)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("multInPlace", 1, 3, 3, 2); __PYX_ERR(13, 1062, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "multInPlace") < 0)) __PYX_ERR(13, 1062, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
    }
    __pyx_v_Q = ((struct PyPetscMatObject *)values[0]);
    __pyx_v_s = values[1];
    __pyx_v_e = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("multInPlace", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1062, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.multInPlace", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Q), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "Q", 0))) __PYX_ERR(13, 1062, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_104multInPlace(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_Q, __pyx_v_s, __pyx_v_e);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_104multInPlace(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_Q, PyObject *__pyx_v_s, PyObject *__pyx_v_e) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("multInPlace", 0);

  /* "SLEPc/BV.pyx":1075
 *            Last column to be overwritten.
 *         """
 *         cdef PetscInt ival1 = asInt(s)             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = asInt(e)
 *         CHKERR( BVMultInPlace(self.bv, Q.mat, ival1, ival2) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_s); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 1075, __pyx_L1_error)
  __pyx_v_ival1 = __pyx_t_1;

  /* "SLEPc/BV.pyx":1076
 *         """
 *         cdef PetscInt ival1 = asInt(s)
 *         cdef PetscInt ival2 = asInt(e)             # <<<<<<<<<<<<<<
 *         CHKERR( BVMultInPlace(self.bv, Q.mat, ival1, ival2) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_e); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 1076, __pyx_L1_error)
  __pyx_v_ival2 = __pyx_t_1;

  /* "SLEPc/BV.pyx":1077
 *         cdef PetscInt ival1 = asInt(s)
 *         cdef PetscInt ival2 = asInt(e)
 *         CHKERR( BVMultInPlace(self.bv, Q.mat, ival1, ival2) )             # <<<<<<<<<<<<<<
 * 
 *     def multColumn(self, alpha, beta, j, q):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVMultInPlace(__pyx_v_self->bv, __pyx_v_Q->mat, __pyx_v_ival1, __pyx_v_ival2)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 1077, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1062
 *         CHKERR( BVMult(self.bv, sval1, sval2, X.bv, Qmat) )
 * 
 *     def multInPlace(self, Mat Q, s, e):             # <<<<<<<<<<<<<<
 *         """
 *         Update a set of vectors as V(:,s:e-1) = V*Q(:,s:e-1).
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.multInPlace", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1079
 *         CHKERR( BVMultInPlace(self.bv, Q.mat, ival1, ival2) )
 * 
 *     def multColumn(self, alpha, beta, j, q):             # <<<<<<<<<<<<<<
 *         """
 *         Computes y = beta*y + alpha*X*q, where y is the j-th column.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_107multColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_106multColumn[] = "BV.multColumn(self, alpha, beta, j, q)\n\n        Computes y = beta*y + alpha*X*q, where y is the j-th column.\n\n        Parameters\n        ----------\n        alpha: scalar\n            Coefficient that multiplies X.\n        beta: scalar\n            Coefficient that multiplies y.\n        j: int\n            The column index.\n        q: Array of scalar\n            Input coefficients.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_107multColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_alpha = 0;
  PyObject *__pyx_v_beta = 0;
  PyObject *__pyx_v_j = 0;
  PyObject *__pyx_v_q = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("multColumn (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alpha,&__pyx_n_s_beta,&__pyx_n_s_j,&__pyx_n_s_q,0};
    PyObject* values[4] = {0,0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_beta)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("multColumn", 1, 4, 4, 1); __PYX_ERR(13, 1079, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("multColumn", 1, 4, 4, 2); __PYX_ERR(13, 1079, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_q)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("multColumn", 1, 4, 4, 3); __PYX_ERR(13, 1079, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "multColumn") < 0)) __PYX_ERR(13, 1079, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
    }
    __pyx_v_alpha = values[0];
    __pyx_v_beta = values[1];
    __pyx_v_j = values[2];
    __pyx_v_q = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("multColumn", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1079, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.multColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_106multColumn(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_alpha, __pyx_v_beta, __pyx_v_j, __pyx_v_q);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_106multColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_alpha, PyObject *__pyx_v_beta, PyObject *__pyx_v_j, PyObject *__pyx_v_q) {
  PetscScalar __pyx_v_sval1;
  PetscScalar __pyx_v_sval2;
  PetscInt __pyx_v_ival;
  PetscInt __pyx_v_nq;
  PetscScalar *__pyx_v_qval;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PetscInt __pyx_v_l;
  PetscInt __pyx_v_k;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  PetscInt __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("multColumn", 0);

  /* "SLEPc/BV.pyx":1094
 *             Input coefficients.
 *         """
 *         cdef PetscScalar sval1 = asScalar(alpha)             # <<<<<<<<<<<<<<
 *         cdef PetscScalar sval2 = asScalar(beta)
 *         cdef PetscInt ival = asInt(j)
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_alpha); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(13, 1094, __pyx_L1_error)
  __pyx_v_sval1 = __pyx_t_1;

  /* "SLEPc/BV.pyx":1095
 *         """
 *         cdef PetscScalar sval1 = asScalar(alpha)
 *         cdef PetscScalar sval2 = asScalar(beta)             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival = asInt(j)
 *         cdef PetscInt nq = 0
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_beta); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(13, 1095, __pyx_L1_error)
  __pyx_v_sval2 = __pyx_t_1;

  /* "SLEPc/BV.pyx":1096
 *         cdef PetscScalar sval1 = asScalar(alpha)
 *         cdef PetscScalar sval2 = asScalar(beta)
 *         cdef PetscInt ival = asInt(j)             # <<<<<<<<<<<<<<
 *         cdef PetscInt nq = 0
 *         cdef PetscScalar* qval = NULL
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_j); if (unlikely(__pyx_t_2 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 1096, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_2;

  /* "SLEPc/BV.pyx":1097
 *         cdef PetscScalar sval2 = asScalar(beta)
 *         cdef PetscInt ival = asInt(j)
 *         cdef PetscInt nq = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar* qval = NULL
 *         cdef tmp = iarray_s(q, &nq, &qval)
 */
  __pyx_v_nq = 0;

  /* "SLEPc/BV.pyx":1098
 *         cdef PetscInt ival = asInt(j)
 *         cdef PetscInt nq = 0
 *         cdef PetscScalar* qval = NULL             # <<<<<<<<<<<<<<
 *         cdef tmp = iarray_s(q, &nq, &qval)
 *         cdef PetscInt l=0, k=0
 */
  __pyx_v_qval = NULL;

  /* "SLEPc/BV.pyx":1099
 *         cdef PetscInt nq = 0
 *         cdef PetscScalar* qval = NULL
 *         cdef tmp = iarray_s(q, &nq, &qval)             # <<<<<<<<<<<<<<
 *         cdef PetscInt l=0, k=0
 *         CHKERR( BVGetActiveColumns(self.bv, &l, &k) )
 */
  __pyx_t_3 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_iarray_s(__pyx_v_q, (&__pyx_v_nq), (&__pyx_v_qval))); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 1099, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/BV.pyx":1100
 *         cdef PetscScalar* qval = NULL
 *         cdef tmp = iarray_s(q, &nq, &qval)
 *         cdef PetscInt l=0, k=0             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetActiveColumns(self.bv, &l, &k) )
 *         assert nq == k-l
 */
  __pyx_v_l = 0;
  __pyx_v_k = 0;

  /* "SLEPc/BV.pyx":1101
 *         cdef tmp = iarray_s(q, &nq, &qval)
 *         cdef PetscInt l=0, k=0
 *         CHKERR( BVGetActiveColumns(self.bv, &l, &k) )             # <<<<<<<<<<<<<<
 *         assert nq == k-l
 *         CHKERR( BVMultColumn(self.bv, sval1, sval2, ival, qval) )
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetActiveColumns(__pyx_v_self->bv, (&__pyx_v_l), (&__pyx_v_k))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 1101, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1102
 *         cdef PetscInt l=0, k=0
 *         CHKERR( BVGetActiveColumns(self.bv, &l, &k) )
 *         assert nq == k-l             # <<<<<<<<<<<<<<
 *         CHKERR( BVMultColumn(self.bv, sval1, sval2, ival, qval) )
 * 
 */
  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(!Py_OptimizeFlag)) {
    if (unlikely(!((__pyx_v_nq == (__pyx_v_k - __pyx_v_l)) != 0))) {
      PyErr_SetNone(PyExc_AssertionError);
      __PYX_ERR(13, 1102, __pyx_L1_error)
    }
  }
  #endif

  /* "SLEPc/BV.pyx":1103
 *         CHKERR( BVGetActiveColumns(self.bv, &l, &k) )
 *         assert nq == k-l
 *         CHKERR( BVMultColumn(self.bv, sval1, sval2, ival, qval) )             # <<<<<<<<<<<<<<
 * 
 *     def multVec(self, alpha, beta, Vec y, q):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVMultColumn(__pyx_v_self->bv, __pyx_v_sval1, __pyx_v_sval2, __pyx_v_ival, __pyx_v_qval)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 1103, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1079
 *         CHKERR( BVMultInPlace(self.bv, Q.mat, ival1, ival2) )
 * 
 *     def multColumn(self, alpha, beta, j, q):             # <<<<<<<<<<<<<<
 *         """
 *         Computes y = beta*y + alpha*X*q, where y is the j-th column.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.multColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1105
 *         CHKERR( BVMultColumn(self.bv, sval1, sval2, ival, qval) )
 * 
 *     def multVec(self, alpha, beta, Vec y, q):             # <<<<<<<<<<<<<<
 *         """
 *         Computes y = beta*y + alpha*X*q.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_109multVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_108multVec[] = "BV.multVec(self, alpha, beta, Vec y, q)\n\n        Computes y = beta*y + alpha*X*q.\n\n        Parameters\n        ----------\n        alpha: scalar\n            Coefficient that multiplies X.\n        beta: scalar\n            Coefficient that multiplies y.\n        y: Vec\n            Input/output vector.\n        q: Array of scalar\n            Input coefficients.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_109multVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_alpha = 0;
  PyObject *__pyx_v_beta = 0;
  struct PyPetscVecObject *__pyx_v_y = 0;
  PyObject *__pyx_v_q = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("multVec (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alpha,&__pyx_n_s_beta,&__pyx_n_s_y,&__pyx_n_s_q,0};
    PyObject* values[4] = {0,0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_beta)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("multVec", 1, 4, 4, 1); __PYX_ERR(13, 1105, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("multVec", 1, 4, 4, 2); __PYX_ERR(13, 1105, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_q)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("multVec", 1, 4, 4, 3); __PYX_ERR(13, 1105, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "multVec") < 0)) __PYX_ERR(13, 1105, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
    }
    __pyx_v_alpha = values[0];
    __pyx_v_beta = values[1];
    __pyx_v_y = ((struct PyPetscVecObject *)values[2]);
    __pyx_v_q = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("multVec", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1105, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.multVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "y", 0))) __PYX_ERR(13, 1105, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_108multVec(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_alpha, __pyx_v_beta, __pyx_v_y, __pyx_v_q);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_108multVec(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_alpha, PyObject *__pyx_v_beta, struct PyPetscVecObject *__pyx_v_y, PyObject *__pyx_v_q) {
  PetscScalar __pyx_v_sval1;
  PetscScalar __pyx_v_sval2;
  PetscInt __pyx_v_nq;
  PetscScalar *__pyx_v_qval;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PetscInt __pyx_v_l;
  PetscInt __pyx_v_k;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("multVec", 0);

  /* "SLEPc/BV.pyx":1120
 *             Input coefficients.
 *         """
 *         cdef PetscScalar sval1 = asScalar(alpha)             # <<<<<<<<<<<<<<
 *         cdef PetscScalar sval2 = asScalar(beta)
 *         cdef PetscInt nq = 0
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_alpha); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(13, 1120, __pyx_L1_error)
  __pyx_v_sval1 = __pyx_t_1;

  /* "SLEPc/BV.pyx":1121
 *         """
 *         cdef PetscScalar sval1 = asScalar(alpha)
 *         cdef PetscScalar sval2 = asScalar(beta)             # <<<<<<<<<<<<<<
 *         cdef PetscInt nq = 0
 *         cdef PetscScalar* qval = NULL
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_beta); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(13, 1121, __pyx_L1_error)
  __pyx_v_sval2 = __pyx_t_1;

  /* "SLEPc/BV.pyx":1122
 *         cdef PetscScalar sval1 = asScalar(alpha)
 *         cdef PetscScalar sval2 = asScalar(beta)
 *         cdef PetscInt nq = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar* qval = NULL
 *         cdef tmp = iarray_s(q, &nq, &qval)
 */
  __pyx_v_nq = 0;

  /* "SLEPc/BV.pyx":1123
 *         cdef PetscScalar sval2 = asScalar(beta)
 *         cdef PetscInt nq = 0
 *         cdef PetscScalar* qval = NULL             # <<<<<<<<<<<<<<
 *         cdef tmp = iarray_s(q, &nq, &qval)
 *         cdef PetscInt l=0, k=0
 */
  __pyx_v_qval = NULL;

  /* "SLEPc/BV.pyx":1124
 *         cdef PetscInt nq = 0
 *         cdef PetscScalar* qval = NULL
 *         cdef tmp = iarray_s(q, &nq, &qval)             # <<<<<<<<<<<<<<
 *         cdef PetscInt l=0, k=0
 *         CHKERR( BVGetActiveColumns(self.bv, &l, &k) )
 */
  __pyx_t_2 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_iarray_s(__pyx_v_q, (&__pyx_v_nq), (&__pyx_v_qval))); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 1124, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_tmp = __pyx_t_2;
  __pyx_t_2 = 0;

  /* "SLEPc/BV.pyx":1125
 *         cdef PetscScalar* qval = NULL
 *         cdef tmp = iarray_s(q, &nq, &qval)
 *         cdef PetscInt l=0, k=0             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetActiveColumns(self.bv, &l, &k) )
 *         assert nq == k-l
 */
  __pyx_v_l = 0;
  __pyx_v_k = 0;

  /* "SLEPc/BV.pyx":1126
 *         cdef tmp = iarray_s(q, &nq, &qval)
 *         cdef PetscInt l=0, k=0
 *         CHKERR( BVGetActiveColumns(self.bv, &l, &k) )             # <<<<<<<<<<<<<<
 *         assert nq == k-l
 *         CHKERR( BVMultVec(self.bv, sval1, sval2, y.vec, qval) )
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetActiveColumns(__pyx_v_self->bv, (&__pyx_v_l), (&__pyx_v_k))); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(13, 1126, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1127
 *         cdef PetscInt l=0, k=0
 *         CHKERR( BVGetActiveColumns(self.bv, &l, &k) )
 *         assert nq == k-l             # <<<<<<<<<<<<<<
 *         CHKERR( BVMultVec(self.bv, sval1, sval2, y.vec, qval) )
 * 
 */
  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(!Py_OptimizeFlag)) {
    if (unlikely(!((__pyx_v_nq == (__pyx_v_k - __pyx_v_l)) != 0))) {
      PyErr_SetNone(PyExc_AssertionError);
      __PYX_ERR(13, 1127, __pyx_L1_error)
    }
  }
  #endif

  /* "SLEPc/BV.pyx":1128
 *         CHKERR( BVGetActiveColumns(self.bv, &l, &k) )
 *         assert nq == k-l
 *         CHKERR( BVMultVec(self.bv, sval1, sval2, y.vec, qval) )             # <<<<<<<<<<<<<<
 * 
 *     def normColumn(self, int j, norm_type=None):
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVMultVec(__pyx_v_self->bv, __pyx_v_sval1, __pyx_v_sval2, __pyx_v_y->vec, __pyx_v_qval)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(13, 1128, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1105
 *         CHKERR( BVMultColumn(self.bv, sval1, sval2, ival, qval) )
 * 
 *     def multVec(self, alpha, beta, Vec y, q):             # <<<<<<<<<<<<<<
 *         """
 *         Computes y = beta*y + alpha*X*q.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.multVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1130
 *         CHKERR( BVMultVec(self.bv, sval1, sval2, y.vec, qval) )
 * 
 *     def normColumn(self, int j, norm_type=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the matrix norm of the BV.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_111normColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_110normColumn[] = "BV.normColumn(self, int j, norm_type=None)\n\n        Computes the matrix norm of the BV.\n\n        Parameters\n        ----------\n        j: int\n            Index of column.\n        norm_type: `PETSc.NormType` enumerate\n            The norm type.\n\n        Returns\n        -------\n        norm: float\n\n        Notes\n        -----\n        The norm of V[j] is computed (NORM_1, NORM_2, or NORM_INFINITY).\n\n        If a non-standard inner product has been specified with BVSetMatrix(),\n        then the returned value is ``sqrt(V[j]'* B*V[j])``, where B is the inner\n        product matrix (argument 'type' is ignored).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_111normColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_j;
  PyObject *__pyx_v_norm_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("normColumn (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_j,&__pyx_n_s_norm_type,0};
    PyObject* values[2] = {0,0};
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_norm_type);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "normColumn") < 0)) __PYX_ERR(13, 1130, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_j = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_j == (int)-1) && PyErr_Occurred())) __PYX_ERR(13, 1130, __pyx_L3_error)
    __pyx_v_norm_type = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("normColumn", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1130, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.normColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_110normColumn(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_j, __pyx_v_norm_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_110normColumn(struct PySlepcBVObject *__pyx_v_self, int __pyx_v_j, PyObject *__pyx_v_norm_type) {
  NormType __pyx_v_ntype;
  PetscReal __pyx_v_norm;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  NormType __pyx_t_3;
  int __pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("normColumn", 0);

  /* "SLEPc/BV.pyx":1153
 *         product matrix (argument 'type' is ignored).
 *         """
 *         cdef PetscNormType ntype = PETSC_NORM_2             # <<<<<<<<<<<<<<
 *         if norm_type is not None: ntype = norm_type
 *         cdef PetscReal norm = 0
 */
  __pyx_v_ntype = NORM_2;

  /* "SLEPc/BV.pyx":1154
 *         """
 *         cdef PetscNormType ntype = PETSC_NORM_2
 *         if norm_type is not None: ntype = norm_type             # <<<<<<<<<<<<<<
 *         cdef PetscReal norm = 0
 *         CHKERR( BVNormColumn(self.bv, j, ntype, &norm) )
 */
  __pyx_t_1 = (__pyx_v_norm_type != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = ((NormType)__Pyx_PyInt_As_NormType(__pyx_v_norm_type)); if (unlikely(PyErr_Occurred())) __PYX_ERR(13, 1154, __pyx_L1_error)
    __pyx_v_ntype = __pyx_t_3;
  }

  /* "SLEPc/BV.pyx":1155
 *         cdef PetscNormType ntype = PETSC_NORM_2
 *         if norm_type is not None: ntype = norm_type
 *         cdef PetscReal norm = 0             # <<<<<<<<<<<<<<
 *         CHKERR( BVNormColumn(self.bv, j, ntype, &norm) )
 *         return toReal(norm)
 */
  __pyx_v_norm = 0.0;

  /* "SLEPc/BV.pyx":1156
 *         if norm_type is not None: ntype = norm_type
 *         cdef PetscReal norm = 0
 *         CHKERR( BVNormColumn(self.bv, j, ntype, &norm) )             # <<<<<<<<<<<<<<
 *         return toReal(norm)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVNormColumn(__pyx_v_self->bv, __pyx_v_j, __pyx_v_ntype, (&__pyx_v_norm))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 1156, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1157
 *         cdef PetscReal norm = 0
 *         CHKERR( BVNormColumn(self.bv, j, ntype, &norm) )
 *         return toReal(norm)             # <<<<<<<<<<<<<<
 * 
 *     def norm(self, norm_type=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_norm); if (unlikely(!__pyx_t_5)) __PYX_ERR(13, 1157, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":1130
 *         CHKERR( BVMultVec(self.bv, sval1, sval2, y.vec, qval) )
 * 
 *     def normColumn(self, int j, norm_type=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the matrix norm of the BV.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.normColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1159
 *         return toReal(norm)
 * 
 *     def norm(self, norm_type=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the matrix norm of the BV.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_113norm(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_112norm[] = "BV.norm(self, norm_type=None)\n\n        Computes the matrix norm of the BV.\n\n        Parameters\n        ----------\n        norm_type: `PETSC.NormType` enumerate\n            The norm type.\n\n        Returns\n        -------\n        norm: float\n\n        Notes\n        -----\n        All active columns (except the leading ones) are considered as a\n        matrix. The allowed norms are NORM_1, NORM_FROBENIUS, and\n        NORM_INFINITY.\n\n        This operation fails if a non-standard inner product has been specified\n        with BVSetMatrix().\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_113norm(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_norm_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("norm (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_norm_type,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_norm_type);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "norm") < 0)) __PYX_ERR(13, 1159, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_norm_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("norm", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1159, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.norm", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_112norm(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_norm_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_112norm(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_norm_type) {
  NormType __pyx_v_ntype;
  PetscReal __pyx_v_norm;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  NormType __pyx_t_3;
  int __pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("norm", 0);

  /* "SLEPc/BV.pyx":1181
 *         with BVSetMatrix().
 *         """
 *         cdef PetscNormType ntype = PETSC_NORM_FROBENIUS             # <<<<<<<<<<<<<<
 *         if norm_type is not None: ntype = norm_type
 *         cdef PetscReal norm = 0
 */
  __pyx_v_ntype = NORM_FROBENIUS;

  /* "SLEPc/BV.pyx":1182
 *         """
 *         cdef PetscNormType ntype = PETSC_NORM_FROBENIUS
 *         if norm_type is not None: ntype = norm_type             # <<<<<<<<<<<<<<
 *         cdef PetscReal norm = 0
 *         CHKERR( BVNorm(self.bv, ntype, &norm) )
 */
  __pyx_t_1 = (__pyx_v_norm_type != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = ((NormType)__Pyx_PyInt_As_NormType(__pyx_v_norm_type)); if (unlikely(PyErr_Occurred())) __PYX_ERR(13, 1182, __pyx_L1_error)
    __pyx_v_ntype = __pyx_t_3;
  }

  /* "SLEPc/BV.pyx":1183
 *         cdef PetscNormType ntype = PETSC_NORM_FROBENIUS
 *         if norm_type is not None: ntype = norm_type
 *         cdef PetscReal norm = 0             # <<<<<<<<<<<<<<
 *         CHKERR( BVNorm(self.bv, ntype, &norm) )
 *         return toReal(norm)
 */
  __pyx_v_norm = 0.0;

  /* "SLEPc/BV.pyx":1184
 *         if norm_type is not None: ntype = norm_type
 *         cdef PetscReal norm = 0
 *         CHKERR( BVNorm(self.bv, ntype, &norm) )             # <<<<<<<<<<<<<<
 *         return toReal(norm)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVNorm(__pyx_v_self->bv, __pyx_v_ntype, (&__pyx_v_norm))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 1184, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1185
 *         cdef PetscReal norm = 0
 *         CHKERR( BVNorm(self.bv, ntype, &norm) )
 *         return toReal(norm)             # <<<<<<<<<<<<<<
 * 
 *     def resize(self, m, copy=True):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_norm); if (unlikely(!__pyx_t_5)) __PYX_ERR(13, 1185, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":1159
 *         return toReal(norm)
 * 
 *     def norm(self, norm_type=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the matrix norm of the BV.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.norm", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1187
 *         return toReal(norm)
 * 
 *     def resize(self, m, copy=True):             # <<<<<<<<<<<<<<
 *         """
 *         Change the number of columns.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_115resize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_114resize[] = "BV.resize(self, m, copy=True)\n\n        Change the number of columns.\n\n        Parameters\n        ----------\n        m: int\n           The new number of columns.\n        copy: bool\n           A flag indicating whether current values should be kept.\n\n        Notes\n        -----\n        Internal storage is reallocated. If copy is True, then the contents are\n        copied to the leading part of the new space.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_115resize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_m = 0;
  PyObject *__pyx_v_copy = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("resize (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_m,&__pyx_n_s_copy,0};
    PyObject* values[2] = {0,0};
    values[1] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_m)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_copy);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "resize") < 0)) __PYX_ERR(13, 1187, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_m = values[0];
    __pyx_v_copy = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("resize", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1187, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_114resize(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_m, __pyx_v_copy);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_114resize(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_m, PyObject *__pyx_v_copy) {
  PetscInt __pyx_v_ival;
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  PetscBool __pyx_t_2;
  int __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("resize", 0);

  /* "SLEPc/BV.pyx":1203
 *         copied to the leading part of the new space.
 *         """
 *         cdef PetscInt ival = asInt(m)             # <<<<<<<<<<<<<<
 *         cdef PetscBool tval = PETSC_TRUE if copy else PETSC_FALSE
 *         CHKERR( BVResize(self.bv, ival, tval) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_m); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 1203, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/BV.pyx":1204
 *         """
 *         cdef PetscInt ival = asInt(m)
 *         cdef PetscBool tval = PETSC_TRUE if copy else PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( BVResize(self.bv, ival, tval) )
 * 
 */
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_copy); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(13, 1204, __pyx_L1_error)
  if (__pyx_t_3) {
    __pyx_t_2 = PETSC_TRUE;
  } else {
    __pyx_t_2 = PETSC_FALSE;
  }
  __pyx_v_tval = __pyx_t_2;

  /* "SLEPc/BV.pyx":1205
 *         cdef PetscInt ival = asInt(m)
 *         cdef PetscBool tval = PETSC_TRUE if copy else PETSC_FALSE
 *         CHKERR( BVResize(self.bv, ival, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def setRandom(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVResize(__pyx_v_self->bv, __pyx_v_ival, __pyx_v_tval)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(13, 1205, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1187
 *         return toReal(norm)
 * 
 *     def resize(self, m, copy=True):             # <<<<<<<<<<<<<<
 *         """
 *         Change the number of columns.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1207
 *         CHKERR( BVResize(self.bv, ival, tval) )
 * 
 *     def setRandom(self):             # <<<<<<<<<<<<<<
 *         """
 *         Set the active columns of the BV to random numbers.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_117setRandom(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_116setRandom[] = "BV.setRandom(self)\n\n        Set the active columns of the BV to random numbers.\n\n        Notes\n        -----\n        All active columns (except the leading ones) are modified.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_117setRandom(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRandom (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setRandom", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setRandom", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_116setRandom(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_116setRandom(struct PySlepcBVObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRandom", 0);

  /* "SLEPc/BV.pyx":1215
 *         All active columns (except the leading ones) are modified.
 *         """
 *         CHKERR( BVSetRandom(self.bv) )             # <<<<<<<<<<<<<<
 * 
 *     def setRandomNormal(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetRandom(__pyx_v_self->bv)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 1215, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1207
 *         CHKERR( BVResize(self.bv, ival, tval) )
 * 
 *     def setRandom(self):             # <<<<<<<<<<<<<<
 *         """
 *         Set the active columns of the BV to random numbers.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setRandom", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1217
 *         CHKERR( BVSetRandom(self.bv) )
 * 
 *     def setRandomNormal(self):             # <<<<<<<<<<<<<<
 *         """
 *         Set the active columns of the BV to random numbers (with normal
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_119setRandomNormal(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_118setRandomNormal[] = "BV.setRandomNormal(self)\n\n        Set the active columns of the BV to random numbers (with normal\n        distribution).\n\n        Notes\n        -----\n        All active columns (except the leading ones) are modified.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_119setRandomNormal(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRandomNormal (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setRandomNormal", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setRandomNormal", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_118setRandomNormal(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_118setRandomNormal(struct PySlepcBVObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRandomNormal", 0);

  /* "SLEPc/BV.pyx":1226
 *         All active columns (except the leading ones) are modified.
 *         """
 *         CHKERR( BVSetRandomNormal(self.bv) )             # <<<<<<<<<<<<<<
 * 
 *     def setRandomSign(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetRandomNormal(__pyx_v_self->bv)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 1226, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1217
 *         CHKERR( BVSetRandom(self.bv) )
 * 
 *     def setRandomNormal(self):             # <<<<<<<<<<<<<<
 *         """
 *         Set the active columns of the BV to random numbers (with normal
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setRandomNormal", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1228
 *         CHKERR( BVSetRandomNormal(self.bv) )
 * 
 *     def setRandomSign(self):             # <<<<<<<<<<<<<<
 *         """
 *         Set the entries of a BV to values 1 or -1 with equal probability.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_121setRandomSign(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_120setRandomSign[] = "BV.setRandomSign(self)\n\n        Set the entries of a BV to values 1 or -1 with equal probability.\n\n        Notes\n        -----\n        All active columns (except the leading ones) are modified.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_121setRandomSign(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRandomSign (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setRandomSign", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setRandomSign", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_120setRandomSign(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_120setRandomSign(struct PySlepcBVObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRandomSign", 0);

  /* "SLEPc/BV.pyx":1236
 *         All active columns (except the leading ones) are modified.
 *         """
 *         CHKERR( BVSetRandomSign(self.bv) )             # <<<<<<<<<<<<<<
 * 
 *     def setRandomColumn(self, j):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetRandomSign(__pyx_v_self->bv)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 1236, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1228
 *         CHKERR( BVSetRandomNormal(self.bv) )
 * 
 *     def setRandomSign(self):             # <<<<<<<<<<<<<<
 *         """
 *         Set the entries of a BV to values 1 or -1 with equal probability.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setRandomSign", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1238
 *         CHKERR( BVSetRandomSign(self.bv) )
 * 
 *     def setRandomColumn(self, j):             # <<<<<<<<<<<<<<
 *         """
 *         Set one column of the BV to random numbers.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_123setRandomColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_122setRandomColumn[] = "BV.setRandomColumn(self, j)\n\n        Set one column of the BV to random numbers.\n\n        Parameters\n        ----------\n        j: int\n           Column number to be set.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_123setRandomColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_j = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRandomColumn (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_j,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRandomColumn") < 0)) __PYX_ERR(13, 1238, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_j = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRandomColumn", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1238, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setRandomColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_122setRandomColumn(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_j);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_122setRandomColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRandomColumn", 0);

  /* "SLEPc/BV.pyx":1247
 *            Column number to be set.
 *         """
 *         cdef PetscInt ival = asInt(j)             # <<<<<<<<<<<<<<
 *         CHKERR( BVSetRandomColumn(self.bv, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_j); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 1247, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/BV.pyx":1248
 *         """
 *         cdef PetscInt ival = asInt(j)
 *         CHKERR( BVSetRandomColumn(self.bv, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def setRandomCond(self, condn):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetRandomColumn(__pyx_v_self->bv, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 1248, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1238
 *         CHKERR( BVSetRandomSign(self.bv) )
 * 
 *     def setRandomColumn(self, j):             # <<<<<<<<<<<<<<
 *         """
 *         Set one column of the BV to random numbers.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setRandomColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1250
 *         CHKERR( BVSetRandomColumn(self.bv, ival) )
 * 
 *     def setRandomCond(self, condn):             # <<<<<<<<<<<<<<
 *         """
 *         Set the columns of a BV to random numbers, in a way that the generated
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_125setRandomCond(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_124setRandomCond[] = "BV.setRandomCond(self, condn)\n\n        Set the columns of a BV to random numbers, in a way that the generated\n        matrix has a given condition number.\n\n        Parameters\n        ----------\n        condn: float\n               Condition number.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_125setRandomCond(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_condn = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRandomCond (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_condn,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_condn)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRandomCond") < 0)) __PYX_ERR(13, 1250, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_condn = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRandomCond", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1250, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setRandomCond", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_124setRandomCond(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_condn);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_124setRandomCond(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_condn) {
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRandomCond", 0);

  /* "SLEPc/BV.pyx":1260
 *                Condition number.
 *         """
 *         cdef PetscReal rval = asReal(condn)             # <<<<<<<<<<<<<<
 *         CHKERR( BVSetRandomCond(self.bv, rval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_condn); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(13, 1260, __pyx_L1_error)
  __pyx_v_rval = __pyx_t_1;

  /* "SLEPc/BV.pyx":1261
 *         """
 *         cdef PetscReal rval = asReal(condn)
 *         CHKERR( BVSetRandomCond(self.bv, rval) )             # <<<<<<<<<<<<<<
 * 
 *     def setRandomContext(self, Random rnd):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetRandomCond(__pyx_v_self->bv, __pyx_v_rval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 1261, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1250
 *         CHKERR( BVSetRandomColumn(self.bv, ival) )
 * 
 *     def setRandomCond(self, condn):             # <<<<<<<<<<<<<<
 *         """
 *         Set the columns of a BV to random numbers, in a way that the generated
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setRandomCond", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1263
 *         CHKERR( BVSetRandomCond(self.bv, rval) )
 * 
 *     def setRandomContext(self, Random rnd):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the `PETSc.Random` object associated with the BV, to be used
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_127setRandomContext(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_126setRandomContext[] = "BV.setRandomContext(self, Random rnd)\n\n        Sets the `PETSc.Random` object associated with the BV, to be used\n        in operations that need random numbers.\n\n        Parameters\n        ----------\n        rnd: `PETSc.Random`\n             The random number generator context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_127setRandomContext(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscRandomObject *__pyx_v_rnd = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRandomContext (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rnd,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rnd)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRandomContext") < 0)) __PYX_ERR(13, 1263, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_rnd = ((struct PyPetscRandomObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRandomContext", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1263, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setRandomContext", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rnd), __pyx_ptype_8petsc4py_5PETSc_Random, 0, "rnd", 0))) __PYX_ERR(13, 1263, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_126setRandomContext(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_rnd);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_126setRandomContext(struct PySlepcBVObject *__pyx_v_self, struct PyPetscRandomObject *__pyx_v_rnd) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRandomContext", 0);

  /* "SLEPc/BV.pyx":1273
 *              The random number generator context.
 *         """
 *         CHKERR( BVSetRandomContext(self.bv, rnd.rnd) )             # <<<<<<<<<<<<<<
 * 
 *     def getRandomContext(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVSetRandomContext(__pyx_v_self->bv, __pyx_v_rnd->rnd)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 1273, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1263
 *         CHKERR( BVSetRandomCond(self.bv, rval) )
 * 
 *     def setRandomContext(self, Random rnd):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the `PETSc.Random` object associated with the BV, to be used
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.setRandomContext", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1275
 *         CHKERR( BVSetRandomContext(self.bv, rnd.rnd) )
 * 
 *     def getRandomContext(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the `PETSc.Random` object associated with the BV.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_129getRandomContext(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_128getRandomContext[] = "BV.getRandomContext(self)\n\n        Gets the `PETSc.Random` object associated with the BV.\n\n        Returns\n        -------\n        rnd: `PETSc.Random`\n             The random number generator context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_129getRandomContext(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRandomContext (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRandomContext", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRandomContext", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_128getRandomContext(((struct PySlepcBVObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_128getRandomContext(struct PySlepcBVObject *__pyx_v_self) {
  struct PyPetscRandomObject *__pyx_v_rnd = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRandomContext", 0);

  /* "SLEPc/BV.pyx":1284
 *              The random number generator context.
 *         """
 *         cdef Random rnd = Random()             # <<<<<<<<<<<<<<
 *         CHKERR( BVGetRandomContext(self.bv, &rnd.rnd) )
 *         PetscINCREF(rnd.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Random)); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 1284, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_rnd = ((struct PyPetscRandomObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/BV.pyx":1285
 *         """
 *         cdef Random rnd = Random()
 *         CHKERR( BVGetRandomContext(self.bv, &rnd.rnd) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(rnd.obj)
 *         return rnd
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVGetRandomContext(__pyx_v_self->bv, (&__pyx_v_rnd->rnd))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 1285, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1286
 *         cdef Random rnd = Random()
 *         CHKERR( BVGetRandomContext(self.bv, &rnd.rnd) )
 *         PetscINCREF(rnd.obj)             # <<<<<<<<<<<<<<
 *         return rnd
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_rnd->__pyx_base.obj));

  /* "SLEPc/BV.pyx":1287
 *         CHKERR( BVGetRandomContext(self.bv, &rnd.rnd) )
 *         PetscINCREF(rnd.obj)
 *         return rnd             # <<<<<<<<<<<<<<
 * 
 *     def orthogonalizeVec(self, Vec v):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_rnd));
  __pyx_r = ((PyObject *)__pyx_v_rnd);
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":1275
 *         CHKERR( BVSetRandomContext(self.bv, rnd.rnd) )
 * 
 *     def getRandomContext(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the `PETSc.Random` object associated with the BV.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.getRandomContext", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_rnd);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1289
 *         return rnd
 * 
 *     def orthogonalizeVec(self, Vec v):             # <<<<<<<<<<<<<<
 *         """
 *         Orthogonalize a vector with respect to a set of vectors.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_131orthogonalizeVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_130orthogonalizeVec[] = "BV.orthogonalizeVec(self, Vec v)\n\n        Orthogonalize a vector with respect to a set of vectors.\n\n        Parameters\n        ----------\n        v:  Vec\n            Vector to be orthogonalized, modified on return.\n\n        Returns\n        -------\n        norm: float\n            The norm of the resulting vector.\n        lindep: bool\n            Flag indicating that refinement did not improve the\n            quality of orthogonalization.\n\n        Notes\n        -----\n        This function applies an orthogonal projector to project\n        vector ``v`` onto the orthogonal complement of the span of the\n        columns of the BV.\n\n        This routine does not normalize the resulting vector.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_131orthogonalizeVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscVecObject *__pyx_v_v = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("orthogonalizeVec (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_v,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_v)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "orthogonalizeVec") < 0)) __PYX_ERR(13, 1289, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_v = ((struct PyPetscVecObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("orthogonalizeVec", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1289, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.orthogonalizeVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "v", 0))) __PYX_ERR(13, 1289, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_130orthogonalizeVec(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_v);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_130orthogonalizeVec(struct PySlepcBVObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_v) {
  PetscReal __pyx_v_norm;
  PetscBool __pyx_v_ldep;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("orthogonalizeVec", 0);

  /* "SLEPc/BV.pyx":1314
 *         This routine does not normalize the resulting vector.
 *         """
 *         cdef PetscReal norm = 0             # <<<<<<<<<<<<<<
 *         cdef PetscBool ldep = PETSC_FALSE
 *         CHKERR( BVOrthogonalizeVec(self.bv, v.vec, NULL, &norm, &ldep) )
 */
  __pyx_v_norm = 0.0;

  /* "SLEPc/BV.pyx":1315
 *         """
 *         cdef PetscReal norm = 0
 *         cdef PetscBool ldep = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( BVOrthogonalizeVec(self.bv, v.vec, NULL, &norm, &ldep) )
 *         return (toReal(norm), toBool(ldep))
 */
  __pyx_v_ldep = PETSC_FALSE;

  /* "SLEPc/BV.pyx":1316
 *         cdef PetscReal norm = 0
 *         cdef PetscBool ldep = PETSC_FALSE
 *         CHKERR( BVOrthogonalizeVec(self.bv, v.vec, NULL, &norm, &ldep) )             # <<<<<<<<<<<<<<
 *         return (toReal(norm), toBool(ldep))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVOrthogonalizeVec(__pyx_v_self->bv, __pyx_v_v->vec, NULL, (&__pyx_v_norm), (&__pyx_v_ldep))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(13, 1316, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1317
 *         cdef PetscBool ldep = PETSC_FALSE
 *         CHKERR( BVOrthogonalizeVec(self.bv, v.vec, NULL, &norm, &ldep) )
 *         return (toReal(norm), toBool(ldep))             # <<<<<<<<<<<<<<
 * 
 *     def orthogonalizeColumn(self, j):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_norm); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 1317, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_ldep); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 1317, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 1317, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":1289
 *         return rnd
 * 
 *     def orthogonalizeVec(self, Vec v):             # <<<<<<<<<<<<<<
 *         """
 *         Orthogonalize a vector with respect to a set of vectors.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.orthogonalizeVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1319
 *         return (toReal(norm), toBool(ldep))
 * 
 *     def orthogonalizeColumn(self, j):             # <<<<<<<<<<<<<<
 *         """
 *         Orthogonalize one of the column vectors with respect to the previous ones.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_133orthogonalizeColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_132orthogonalizeColumn[] = "BV.orthogonalizeColumn(self, j)\n\n        Orthogonalize one of the column vectors with respect to the previous ones.\n\n        Parameters\n        ----------\n        j: int\n           Index of the column to be orthogonalized.\n\n        Returns\n        -------\n        norm: float\n            The norm of the resulting vector.\n        lindep: bool\n            Flag indicating that refinement did not improve the\n            quality of orthogonalization.\n\n        Notes\n        -----\n        This function applies an orthogonal projector to project\n        vector ``V[j]`` onto the orthogonal complement of the span of the\n        columns ``V[0..j-1]``, where ``V[.]`` are the vectors of the BV.\n        The columns ``V[0..j-1]`` are assumed to be mutually orthonormal.\n\n        This routine does not normalize the resulting vector.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_133orthogonalizeColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_j = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("orthogonalizeColumn (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_j,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "orthogonalizeColumn") < 0)) __PYX_ERR(13, 1319, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_j = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("orthogonalizeColumn", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1319, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.orthogonalizeColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_132orthogonalizeColumn(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_j);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_132orthogonalizeColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j) {
  PetscInt __pyx_v_ival;
  PetscReal __pyx_v_norm;
  PetscBool __pyx_v_ldep;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("orthogonalizeColumn", 0);

  /* "SLEPc/BV.pyx":1345
 *         This routine does not normalize the resulting vector.
 *         """
 *         cdef PetscInt ival = asInt(j)             # <<<<<<<<<<<<<<
 *         cdef PetscReal norm = 0
 *         cdef PetscBool ldep = PETSC_FALSE
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_j); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 1345, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/BV.pyx":1346
 *         """
 *         cdef PetscInt ival = asInt(j)
 *         cdef PetscReal norm = 0             # <<<<<<<<<<<<<<
 *         cdef PetscBool ldep = PETSC_FALSE
 *         CHKERR( BVOrthogonalizeColumn(self.bv, ival, NULL, &norm, &ldep) )
 */
  __pyx_v_norm = 0.0;

  /* "SLEPc/BV.pyx":1347
 *         cdef PetscInt ival = asInt(j)
 *         cdef PetscReal norm = 0
 *         cdef PetscBool ldep = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( BVOrthogonalizeColumn(self.bv, ival, NULL, &norm, &ldep) )
 *         return (toReal(norm), toBool(ldep))
 */
  __pyx_v_ldep = PETSC_FALSE;

  /* "SLEPc/BV.pyx":1348
 *         cdef PetscReal norm = 0
 *         cdef PetscBool ldep = PETSC_FALSE
 *         CHKERR( BVOrthogonalizeColumn(self.bv, ival, NULL, &norm, &ldep) )             # <<<<<<<<<<<<<<
 *         return (toReal(norm), toBool(ldep))
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVOrthogonalizeColumn(__pyx_v_self->bv, __pyx_v_ival, NULL, (&__pyx_v_norm), (&__pyx_v_ldep))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(13, 1348, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1349
 *         cdef PetscBool ldep = PETSC_FALSE
 *         CHKERR( BVOrthogonalizeColumn(self.bv, ival, NULL, &norm, &ldep) )
 *         return (toReal(norm), toBool(ldep))             # <<<<<<<<<<<<<<
 * 
 *     def orthonormalizeColumn(self, j, replace=False):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_norm); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 1349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_ldep); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 1349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(13, 1349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":1319
 *         return (toReal(norm), toBool(ldep))
 * 
 *     def orthogonalizeColumn(self, j):             # <<<<<<<<<<<<<<
 *         """
 *         Orthogonalize one of the column vectors with respect to the previous ones.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.orthogonalizeColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1351
 *         return (toReal(norm), toBool(ldep))
 * 
 *     def orthonormalizeColumn(self, j, replace=False):             # <<<<<<<<<<<<<<
 *         """
 *         Orthonormalize one of the column vectors with respect to the previous
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_135orthonormalizeColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_134orthonormalizeColumn[] = "BV.orthonormalizeColumn(self, j, replace=False)\n\n        Orthonormalize one of the column vectors with respect to the previous\n        ones.  This is equivalent to a call to `orthogonalizeColumn()`\n        followed by a call to `scaleColumn()` with the reciprocal of the norm.\n\n        Parameters\n        ----------\n        j: int\n           Index of the column to be orthonormalized.\n        replace: bool, optional\n           Whether it is allowed to set the vector randomly.\n\n        Returns\n        -------\n        norm: float\n            The norm of the resulting vector.\n        lindep: bool\n            Flag indicating that refinement did not improve the\n            quality of orthogonalization.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_135orthonormalizeColumn(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_j = 0;
  PyObject *__pyx_v_replace = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("orthonormalizeColumn (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_j,&__pyx_n_s_replace,0};
    PyObject* values[2] = {0,0};
    values[1] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_j)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_replace);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "orthonormalizeColumn") < 0)) __PYX_ERR(13, 1351, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_j = values[0];
    __pyx_v_replace = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("orthonormalizeColumn", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1351, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.orthonormalizeColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_134orthonormalizeColumn(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_j, __pyx_v_replace);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_134orthonormalizeColumn(struct PySlepcBVObject *__pyx_v_self, PyObject *__pyx_v_j, PyObject *__pyx_v_replace) {
  PetscInt __pyx_v_ival;
  PetscBool __pyx_v_bval;
  PetscReal __pyx_v_norm;
  PetscBool __pyx_v_ldep;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PetscBool __pyx_t_4;
  int __pyx_t_5;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("orthonormalizeColumn", 0);

  /* "SLEPc/BV.pyx":1372
 *             quality of orthogonalization.
 *         """
 *         cdef PetscInt ival = asInt(j)             # <<<<<<<<<<<<<<
 *         cdef PetscBool bval = PETSC_FALSE
 *         if replace is not None: bval = asBool(replace)
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_j); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(13, 1372, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/BV.pyx":1373
 *         """
 *         cdef PetscInt ival = asInt(j)
 *         cdef PetscBool bval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         if replace is not None: bval = asBool(replace)
 *         cdef PetscReal norm = 0
 */
  __pyx_v_bval = PETSC_FALSE;

  /* "SLEPc/BV.pyx":1374
 *         cdef PetscInt ival = asInt(j)
 *         cdef PetscBool bval = PETSC_FALSE
 *         if replace is not None: bval = asBool(replace)             # <<<<<<<<<<<<<<
 *         cdef PetscReal norm = 0
 *         cdef PetscBool ldep = PETSC_FALSE
 */
  __pyx_t_2 = (__pyx_v_replace != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_replace); if (unlikely(__pyx_t_4 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(13, 1374, __pyx_L1_error)
    __pyx_v_bval = __pyx_t_4;
  }

  /* "SLEPc/BV.pyx":1375
 *         cdef PetscBool bval = PETSC_FALSE
 *         if replace is not None: bval = asBool(replace)
 *         cdef PetscReal norm = 0             # <<<<<<<<<<<<<<
 *         cdef PetscBool ldep = PETSC_FALSE
 *         CHKERR( BVOrthonormalizeColumn(self.bv, ival, bval, &norm, &ldep) )
 */
  __pyx_v_norm = 0.0;

  /* "SLEPc/BV.pyx":1376
 *         if replace is not None: bval = asBool(replace)
 *         cdef PetscReal norm = 0
 *         cdef PetscBool ldep = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( BVOrthonormalizeColumn(self.bv, ival, bval, &norm, &ldep) )
 *         return (toReal(norm), toBool(ldep))
 */
  __pyx_v_ldep = PETSC_FALSE;

  /* "SLEPc/BV.pyx":1377
 *         cdef PetscReal norm = 0
 *         cdef PetscBool ldep = PETSC_FALSE
 *         CHKERR( BVOrthonormalizeColumn(self.bv, ival, bval, &norm, &ldep) )             # <<<<<<<<<<<<<<
 *         return (toReal(norm), toBool(ldep))
 * 
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVOrthonormalizeColumn(__pyx_v_self->bv, __pyx_v_ival, __pyx_v_bval, (&__pyx_v_norm), (&__pyx_v_ldep))); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(13, 1377, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1378
 *         cdef PetscBool ldep = PETSC_FALSE
 *         CHKERR( BVOrthonormalizeColumn(self.bv, ival, bval, &norm, &ldep) )
 *         return (toReal(norm), toBool(ldep))             # <<<<<<<<<<<<<<
 * 
 *     def orthogonalize(self, Mat R=None, **kargs):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_norm); if (unlikely(!__pyx_t_6)) __PYX_ERR(13, 1378, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_ldep); if (unlikely(!__pyx_t_7)) __PYX_ERR(13, 1378, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(13, 1378, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_7);
  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7);
  __pyx_t_6 = 0;
  __pyx_t_7 = 0;
  __pyx_r = __pyx_t_8;
  __pyx_t_8 = 0;
  goto __pyx_L0;

  /* "SLEPc/BV.pyx":1351
 *         return (toReal(norm), toBool(ldep))
 * 
 *     def orthonormalizeColumn(self, j, replace=False):             # <<<<<<<<<<<<<<
 *         """
 *         Orthonormalize one of the column vectors with respect to the previous
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.orthonormalizeColumn", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/BV.pyx":1380
 *         return (toReal(norm), toBool(ldep))
 * 
 *     def orthogonalize(self, Mat R=None, **kargs):             # <<<<<<<<<<<<<<
 *         """
 *         Orthogonalize all columns (except leading ones),
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_137orthogonalize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2BV_136orthogonalize[] = "BV.orthogonalize(self, Mat R=None, **kargs)\n\n        Orthogonalize all columns (except leading ones),\n        that is, compute the QR decomposition.\n\n        Parameters\n        ----------\n        R: Mat, optional\n            A sequential dense matrix.\n\n        Notes\n        -----\n        The output satisfies ``V0 = V*R`` (where V0 represent the input V) and ``V'*V = I``.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2BV_137orthogonalize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_R = 0;
  PyObject *__pyx_v_kargs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("orthogonalize (wrapper)", 0);
  __pyx_v_kargs = PyDict_New(); if (unlikely(!__pyx_v_kargs)) return NULL;
  __Pyx_GOTREF(__pyx_v_kargs);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_R,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscMatObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_R);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kargs, values, pos_args, "orthogonalize") < 0)) __PYX_ERR(13, 1380, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_R = ((struct PyPetscMatObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("orthogonalize", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(13, 1380, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_DECREF(__pyx_v_kargs); __pyx_v_kargs = 0;
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.orthogonalize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_R), __pyx_ptype_8petsc4py_5PETSc_Mat, 1, "R", 0))) __PYX_ERR(13, 1380, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2BV_136orthogonalize(((struct PySlepcBVObject *)__pyx_v_self), __pyx_v_R, __pyx_v_kargs);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2BV_136orthogonalize(struct PySlepcBVObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_R, PyObject *__pyx_v_kargs) {
  Mat __pyx_v_Rmat;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  Mat __pyx_t_5;
  int __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("orthogonalize", 0);

  /* "SLEPc/BV.pyx":1394
 *         The output satisfies ``V0 = V*R`` (where V0 represent the input V) and ``V'*V = I``.
 *         """
 *         if kargs: self.setOrthogonalization(**kargs)             # <<<<<<<<<<<<<<
 *         cdef PetscMat Rmat = <PetscMat>NULL if R is None else R.mat
 *         CHKERR( BVOrthogonalize(self.bv, Rmat) )
 */
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_kargs); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(13, 1394, __pyx_L1_error)
  if (__pyx_t_1) {
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setOrthogonalization); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 1394, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PyDict_Copy(__pyx_v_kargs); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 1394, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 1394, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  }

  /* "SLEPc/BV.pyx":1395
 *         """
 *         if kargs: self.setOrthogonalization(**kargs)
 *         cdef PetscMat Rmat = <PetscMat>NULL if R is None else R.mat             # <<<<<<<<<<<<<<
 *         CHKERR( BVOrthogonalize(self.bv, Rmat) )
 * 
 */
  __pyx_t_1 = (((PyObject *)__pyx_v_R) == Py_None);
  if ((__pyx_t_1 != 0)) {
    __pyx_t_5 = ((Mat)NULL);
  } else {
    __pyx_t_5 = __pyx_v_R->mat;
  }
  __pyx_v_Rmat = __pyx_t_5;

  /* "SLEPc/BV.pyx":1396
 *         if kargs: self.setOrthogonalization(**kargs)
 *         cdef PetscMat Rmat = <PetscMat>NULL if R is None else R.mat
 *         CHKERR( BVOrthogonalize(self.bv, Rmat) )             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_CHKERR(BVOrthogonalize(__pyx_v_self->bv, __pyx_v_Rmat)); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(13, 1396, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1380
 *         return (toReal(norm), toBool(ldep))
 * 
 *     def orthogonalize(self, Mat R=None, **kargs):             # <<<<<<<<<<<<<<
 *         """
 *         Orthogonalize all columns (except leading ones),
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.BV.orthogonalize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":87
 *     ParallelType = DSParallelType
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.ds
 *         self.ds = NULL
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2DS_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2DS_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS___cinit__(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2DS___cinit__(struct PySlepcDSObject *__pyx_v_self) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "SLEPc/DS.pyx":88
 * 
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.ds             # <<<<<<<<<<<<<<
 *         self.ds = NULL
 * 
 */
  __pyx_v_self->__pyx_base.obj = ((PetscObject *)(&__pyx_v_self->ds));

  /* "SLEPc/DS.pyx":89
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.ds
 *         self.ds = NULL             # <<<<<<<<<<<<<<
 * 
 *     def view(self, Viewer viewer=None):
 */
  __pyx_v_self->ds = NULL;

  /* "SLEPc/DS.pyx":87
 *     ParallelType = DSParallelType
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.ds
 *         self.ds = NULL
 */

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":91
 *         self.ds = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the DS data structure.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_2view[] = "DS.view(self, Viewer viewer=None)\n\n        Prints the DS data structure.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("view (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "view") < 0)) __PYX_ERR(14, 91, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("view", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 91, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(14, 91, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_2view(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_2view(struct PySlepcDSObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("view", 0);

  /* "SLEPc/DS.pyx":101
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( DSView(self.ds, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/DS.pyx":102
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( DSView(self.ds, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def destroy(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSView(__pyx_v_self->ds, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 102, __pyx_L1_error)

  /* "SLEPc/DS.pyx":91
 *         self.ds = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the DS data structure.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":104
 *         CHKERR( DSView(self.ds, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the DS object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_4destroy[] = "DS.destroy(self)\n\n        Destroys the DS object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("destroy (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("destroy", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "destroy", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_4destroy(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_4destroy(struct PySlepcDSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("destroy", 0);

  /* "SLEPc/DS.pyx":108
 *         Destroys the DS object.
 *         """
 *         CHKERR( DSDestroy(&self.ds) )             # <<<<<<<<<<<<<<
 *         self.ds = NULL
 *         return self
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSDestroy((&__pyx_v_self->ds))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 108, __pyx_L1_error)

  /* "SLEPc/DS.pyx":109
 *         """
 *         CHKERR( DSDestroy(&self.ds) )
 *         self.ds = NULL             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  __pyx_v_self->ds = NULL;

  /* "SLEPc/DS.pyx":110
 *         CHKERR( DSDestroy(&self.ds) )
 *         self.ds = NULL
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def reset(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":104
 *         CHKERR( DSView(self.ds, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the DS object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.destroy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":112
 *         return self
 * 
 *     def reset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Resets the DS object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_7reset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_6reset[] = "DS.reset(self)\n\n        Resets the DS object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_7reset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("reset (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("reset", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "reset", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_6reset(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_6reset(struct PySlepcDSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("reset", 0);

  /* "SLEPc/DS.pyx":116
 *         Resets the DS object.
 *         """
 *         CHKERR( DSReset(self.ds) )             # <<<<<<<<<<<<<<
 * 
 *     def create(self, comm=None):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSReset(__pyx_v_self->ds)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 116, __pyx_L1_error)

  /* "SLEPc/DS.pyx":112
 *         return self
 * 
 *     def reset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Resets the DS object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.reset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":118
 *         CHKERR( DSReset(self.ds) )
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the DS object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_9create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_8create[] = "DS.create(self, comm=None)\n\n        Creates the DS object.\n\n        Parameters\n        ----------\n        comm: Comm, optional\n              MPI communicator; if not provided, it defaults to all\n              processes.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_9create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comm = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comm,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comm);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create") < 0)) __PYX_ERR(14, 118, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_comm = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("create", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 118, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_8create(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_comm);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_8create(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_comm) {
  MPI_Comm __pyx_v_ccomm;
  DS __pyx_v_newds;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  MPI_Comm __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("create", 0);

  /* "SLEPc/DS.pyx":128
 *               processes.
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())             # <<<<<<<<<<<<<<
 *         cdef SlepcDS newds = NULL
 *         CHKERR( DSCreate(ccomm, &newds) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_def_Comm(__pyx_v_comm, __pyx_f_8slepc4py_5SLEPc_SLEPC_COMM_DEFAULT()); if (unlikely(PyErr_Occurred())) __PYX_ERR(14, 128, __pyx_L1_error)
  __pyx_v_ccomm = __pyx_t_1;

  /* "SLEPc/DS.pyx":129
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcDS newds = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( DSCreate(ccomm, &newds) )
 *         SlepcCLEAR(self.obj); self.ds = newds
 */
  __pyx_v_newds = NULL;

  /* "SLEPc/DS.pyx":130
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcDS newds = NULL
 *         CHKERR( DSCreate(ccomm, &newds) )             # <<<<<<<<<<<<<<
 *         SlepcCLEAR(self.obj); self.ds = newds
 *         return self
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSCreate(__pyx_v_ccomm, (&__pyx_v_newds))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 130, __pyx_L1_error)

  /* "SLEPc/DS.pyx":131
 *         cdef SlepcDS newds = NULL
 *         CHKERR( DSCreate(ccomm, &newds) )
 *         SlepcCLEAR(self.obj); self.ds = newds             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_SlepcCLEAR(__pyx_v_self->__pyx_base.obj));
  __pyx_v_self->ds = __pyx_v_newds;

  /* "SLEPc/DS.pyx":132
 *         CHKERR( DSCreate(ccomm, &newds) )
 *         SlepcCLEAR(self.obj); self.ds = newds
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def setType(self, ds_type):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":118
 *         CHKERR( DSReset(self.ds) )
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the DS object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":134
 *         return self
 * 
 *     def setType(self, ds_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the type for the DS object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_11setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_10setType[] = "DS.setType(self, ds_type)\n\n        Selects the type for the DS object.\n\n        Parameters\n        ----------\n        ds_type: `DS.Type` enumerate\n                  The direct solver type to be used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_11setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_ds_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ds_type,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ds_type)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setType") < 0)) __PYX_ERR(14, 134, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_ds_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 134, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_10setType(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_ds_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_10setType(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_ds_type) {
  const char* __pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setType", 0);
  __Pyx_INCREF(__pyx_v_ds_type);

  /* "SLEPc/DS.pyx":143
 *                   The direct solver type to be used.
 *         """
 *         cdef SlepcDSType cval = NULL             # <<<<<<<<<<<<<<
 *         ds_type = str2bytes(ds_type, &cval)
 *         CHKERR( DSSetType(self.ds, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/DS.pyx":144
 *         """
 *         cdef SlepcDSType cval = NULL
 *         ds_type = str2bytes(ds_type, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( DSSetType(self.ds, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_ds_type, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 144, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_ds_type, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/DS.pyx":145
 *         cdef SlepcDSType cval = NULL
 *         ds_type = str2bytes(ds_type, &cval)
 *         CHKERR( DSSetType(self.ds, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getType(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSSetType(__pyx_v_self->ds, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 145, __pyx_L1_error)

  /* "SLEPc/DS.pyx":134
 *         return self
 * 
 *     def setType(self, ds_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the type for the DS object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_ds_type);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":147
 *         CHKERR( DSSetType(self.ds, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the DS type of this object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_13getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_12getType[] = "DS.getType(self)\n\n        Gets the DS type of this object.\n\n        Returns\n        -------\n        type: `DS.Type` enumerate\n              The direct solver type currently being used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_13getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_12getType(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_12getType(struct PySlepcDSObject *__pyx_v_self) {
  const char* __pyx_v_ds_type;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getType", 0);

  /* "SLEPc/DS.pyx":156
 *               The direct solver type currently being used.
 *         """
 *         cdef SlepcDSType ds_type = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( DSGetType(self.ds, &ds_type) )
 *         return bytes2str(ds_type)
 */
  __pyx_v_ds_type = NULL;

  /* "SLEPc/DS.pyx":157
 *         """
 *         cdef SlepcDSType ds_type = NULL
 *         CHKERR( DSGetType(self.ds, &ds_type) )             # <<<<<<<<<<<<<<
 *         return bytes2str(ds_type)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSGetType(__pyx_v_self->ds, (&__pyx_v_ds_type))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 157, __pyx_L1_error)

  /* "SLEPc/DS.pyx":158
 *         cdef SlepcDSType ds_type = NULL
 *         CHKERR( DSGetType(self.ds, &ds_type) )
 *         return bytes2str(ds_type)             # <<<<<<<<<<<<<<
 * 
 *     def setOptionsPrefix(self, prefix):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_ds_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 158, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":147
 *         CHKERR( DSSetType(self.ds, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the DS type of this object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":160
 *         return bytes2str(ds_type)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all DS options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_15setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_14setOptionsPrefix[] = "DS.setOptionsPrefix(self, prefix)\n\n        Sets the prefix used for searching for all DS options in the\n        database.\n\n        Parameters\n        ----------\n        prefix: string\n                The prefix string to prepend to all DS option\n                requests.\n\n        Notes\n        -----\n        A hyphen (``-``) must NOT be given at the beginning of the\n        prefix name.  The first character of all runtime options is\n        AUTOMATICALLY the hyphen.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_15setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOptionsPrefix") < 0)) __PYX_ERR(14, 160, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 160, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_14setOptionsPrefix(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_14setOptionsPrefix(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/DS.pyx":177
 *         AUTOMATICALLY the hyphen.
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( DSSetOptionsPrefix(self.ds, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/DS.pyx":178
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( DSSetOptionsPrefix(self.ds, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/DS.pyx":179
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( DSSetOptionsPrefix(self.ds, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getOptionsPrefix(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSSetOptionsPrefix(__pyx_v_self->ds, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 179, __pyx_L1_error)

  /* "SLEPc/DS.pyx":160
 *         return bytes2str(ds_type)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all DS options in the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":181
 *         CHKERR( DSSetOptionsPrefix(self.ds, cval) )
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all DS options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_17getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_16getOptionsPrefix[] = "DS.getOptionsPrefix(self)\n\n        Gets the prefix used for searching for all DS options in the\n        database.\n\n        Returns\n        -------\n        prefix: string\n                The prefix string set for this DS object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_17getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOptionsPrefix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOptionsPrefix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOptionsPrefix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_16getOptionsPrefix(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_16getOptionsPrefix(struct PySlepcDSObject *__pyx_v_self) {
  const char *__pyx_v_prefix;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOptionsPrefix", 0);

  /* "SLEPc/DS.pyx":191
 *                 The prefix string set for this DS object.
 *         """
 *         cdef const_char *prefix = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( DSGetOptionsPrefix(self.ds, &prefix) )
 *         return bytes2str(prefix)
 */
  __pyx_v_prefix = NULL;

  /* "SLEPc/DS.pyx":192
 *         """
 *         cdef const_char *prefix = NULL
 *         CHKERR( DSGetOptionsPrefix(self.ds, &prefix) )             # <<<<<<<<<<<<<<
 *         return bytes2str(prefix)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSGetOptionsPrefix(__pyx_v_self->ds, (&__pyx_v_prefix))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 192, __pyx_L1_error)

  /* "SLEPc/DS.pyx":193
 *         cdef const_char *prefix = NULL
 *         CHKERR( DSGetOptionsPrefix(self.ds, &prefix) )
 *         return bytes2str(prefix)             # <<<<<<<<<<<<<<
 * 
 *     def setFromOptions(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_prefix); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":181
 *         CHKERR( DSSetOptionsPrefix(self.ds, cval) )
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all DS options in the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":195
 *         return bytes2str(prefix)
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets DS options from the options database.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_19setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_18setFromOptions[] = "DS.setFromOptions(self)\n\n        Sets DS options from the options database.\n\n        Notes\n        -----\n        To see all options, run your program with the ``-help``\n        option.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_19setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFromOptions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setFromOptions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setFromOptions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_18setFromOptions(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_18setFromOptions(struct PySlepcDSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFromOptions", 0);

  /* "SLEPc/DS.pyx":204
 *         option.
 *         """
 *         CHKERR( DSSetFromOptions(self.ds) )             # <<<<<<<<<<<<<<
 * 
 *     def duplicate(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSSetFromOptions(__pyx_v_self->ds)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 204, __pyx_L1_error)

  /* "SLEPc/DS.pyx":195
 *         return bytes2str(prefix)
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets DS options from the options database.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setFromOptions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":206
 *         CHKERR( DSSetFromOptions(self.ds) )
 * 
 *     def duplicate(self):             # <<<<<<<<<<<<<<
 *         """
 *         Duplicate the DS object with the same type and dimensions.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_21duplicate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_20duplicate[] = "DS.duplicate(self)\n\n        Duplicate the DS object with the same type and dimensions.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_21duplicate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("duplicate (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("duplicate", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "duplicate", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_20duplicate(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_20duplicate(struct PySlepcDSObject *__pyx_v_self) {
  struct PySlepcDSObject *__pyx_v_ds = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("duplicate", 0);

  /* "SLEPc/DS.pyx":210
 *         Duplicate the DS object with the same type and dimensions.
 *         """
 *         cdef DS ds = type(self)()             # <<<<<<<<<<<<<<
 *         CHKERR( DSDuplicate(self.ds, &ds.ds) )
 *         return ds
 */
  __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
  __pyx_t_2 = ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))); __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 210, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_8slepc4py_5SLEPc_DS))))) __PYX_ERR(14, 210, __pyx_L1_error)
  __pyx_v_ds = ((struct PySlepcDSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/DS.pyx":211
 *         """
 *         cdef DS ds = type(self)()
 *         CHKERR( DSDuplicate(self.ds, &ds.ds) )             # <<<<<<<<<<<<<<
 *         return ds
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSDuplicate(__pyx_v_self->ds, (&__pyx_v_ds->ds))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(14, 211, __pyx_L1_error)

  /* "SLEPc/DS.pyx":212
 *         cdef DS ds = type(self)()
 *         CHKERR( DSDuplicate(self.ds, &ds.ds) )
 *         return ds             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ds));
  __pyx_r = ((PyObject *)__pyx_v_ds);
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":206
 *         CHKERR( DSSetFromOptions(self.ds) )
 * 
 *     def duplicate(self):             # <<<<<<<<<<<<<<
 *         """
 *         Duplicate the DS object with the same type and dimensions.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.duplicate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ds);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":216
 *     #
 * 
 *     def allocate(self, ld):             # <<<<<<<<<<<<<<
 *         """
 *         Allocates memory for internal storage or matrices in DS.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_23allocate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_22allocate[] = "DS.allocate(self, ld)\n\n        Allocates memory for internal storage or matrices in DS.\n\n        Parameters\n        ----------\n        ld: int\n            Leading dimension (maximum allowed dimension for the\n            matrices, including the extra row if present).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_23allocate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_ld = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("allocate (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ld,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ld)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "allocate") < 0)) __PYX_ERR(14, 216, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_ld = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("allocate", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 216, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.allocate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_22allocate(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_ld);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_22allocate(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_ld) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("allocate", 0);

  /* "SLEPc/DS.pyx":226
 *             matrices, including the extra row if present).
 *         """
 *         cdef PetscInt val = asInt(ld)             # <<<<<<<<<<<<<<
 *         CHKERR( DSAllocate(self.ds, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_ld); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(14, 226, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/DS.pyx":227
 *         """
 *         cdef PetscInt val = asInt(ld)
 *         CHKERR( DSAllocate(self.ds, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getLeadingDimension(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSAllocate(__pyx_v_self->ds, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 227, __pyx_L1_error)

  /* "SLEPc/DS.pyx":216
 *     #
 * 
 *     def allocate(self, ld):             # <<<<<<<<<<<<<<
 *         """
 *         Allocates memory for internal storage or matrices in DS.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.allocate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":229
 *         CHKERR( DSAllocate(self.ds, val) )
 * 
 *     def getLeadingDimension(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the leading dimension of the allocated matrices.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_25getLeadingDimension(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_24getLeadingDimension[] = "DS.getLeadingDimension(self)\n\n        Returns the leading dimension of the allocated matrices.\n\n        Returns\n        -------\n        ld: int\n            Leading dimension (maximum allowed dimension for the matrices).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_25getLeadingDimension(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getLeadingDimension (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getLeadingDimension", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLeadingDimension", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_24getLeadingDimension(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_24getLeadingDimension(struct PySlepcDSObject *__pyx_v_self) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getLeadingDimension", 0);

  /* "SLEPc/DS.pyx":238
 *             Leading dimension (maximum allowed dimension for the matrices).
 *         """
 *         cdef PetscInt val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( DSGetLeadingDimension(self.ds, &val) )
 *         return toInt(val)
 */
  __pyx_v_val = 0;

  /* "SLEPc/DS.pyx":239
 *         """
 *         cdef PetscInt val = 0
 *         CHKERR( DSGetLeadingDimension(self.ds, &val) )             # <<<<<<<<<<<<<<
 *         return toInt(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSGetLeadingDimension(__pyx_v_self->ds, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 239, __pyx_L1_error)

  /* "SLEPc/DS.pyx":240
 *         cdef PetscInt val = 0
 *         CHKERR( DSGetLeadingDimension(self.ds, &val) )
 *         return toInt(val)             # <<<<<<<<<<<<<<
 * 
 *     def setState(self, state):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 240, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":229
 *         CHKERR( DSAllocate(self.ds, val) )
 * 
 *     def getLeadingDimension(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the leading dimension of the allocated matrices.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getLeadingDimension", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":242
 *         return toInt(val)
 * 
 *     def setState(self, state):             # <<<<<<<<<<<<<<
 *         """
 *         Change the state of the DS object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_27setState(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_26setState[] = "DS.setState(self, state)\n\n        Change the state of the DS object.\n\n        Parameters\n        ----------\n        state: `DS.StateType` enumerate\n               The new state.\n\n        Notes\n        -----\n        The state indicates that the dense system is in an initial\n        state (raw), in an intermediate state (such as tridiagonal,\n        Hessenberg or Hessenberg-triangular), in a condensed state\n        (such as diagonal, Schur or generalized Schur), or in a\n        truncated state.\n\n        This function is normally used to return to the raw state when\n        the condensed structure is destroyed.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_27setState(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_state = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setState (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setState") < 0)) __PYX_ERR(14, 242, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_state = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setState", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 242, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_26setState(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_state);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_26setState(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_state) {
  DSStateType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  DSStateType __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setState", 0);

  /* "SLEPc/DS.pyx":262
 *         the condensed structure is destroyed.
 *         """
 *         cdef SlepcDSStateType val = state             # <<<<<<<<<<<<<<
 *         CHKERR( DSSetState(self.ds, val) )
 * 
 */
  __pyx_t_1 = ((DSStateType)__Pyx_PyInt_As_DSStateType(__pyx_v_state)); if (unlikely(PyErr_Occurred())) __PYX_ERR(14, 262, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/DS.pyx":263
 *         """
 *         cdef SlepcDSStateType val = state
 *         CHKERR( DSSetState(self.ds, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getState(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSSetState(__pyx_v_self->ds, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 263, __pyx_L1_error)

  /* "SLEPc/DS.pyx":242
 *         return toInt(val)
 * 
 *     def setState(self, state):             # <<<<<<<<<<<<<<
 *         """
 *         Change the state of the DS object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":265
 *         CHKERR( DSSetState(self.ds, val) )
 * 
 *     def getState(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the current state.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_29getState(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_28getState[] = "DS.getState(self)\n\n        Returns the current state.\n\n        Returns\n        -------\n        state: `DS.StateType` enumerate\n               The current state.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_29getState(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getState (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getState", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getState", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_28getState(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_28getState(struct PySlepcDSObject *__pyx_v_self) {
  DSStateType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getState", 0);

  /* "SLEPc/DS.pyx":274
 *                The current state.
 *         """
 *         cdef SlepcDSStateType val = DS_STATE_RAW             # <<<<<<<<<<<<<<
 *         CHKERR( DSGetState(self.ds, &val) )
 *         return val
 */
  __pyx_v_val = DS_STATE_RAW;

  /* "SLEPc/DS.pyx":275
 *         """
 *         cdef SlepcDSStateType val = DS_STATE_RAW
 *         CHKERR( DSGetState(self.ds, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSGetState(__pyx_v_self->ds, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 275, __pyx_L1_error)

  /* "SLEPc/DS.pyx":276
 *         cdef SlepcDSStateType val = DS_STATE_RAW
 *         CHKERR( DSGetState(self.ds, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setParallel(self, pmode):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_DSStateType(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 276, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":265
 *         CHKERR( DSSetState(self.ds, val) )
 * 
 *     def getState(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the current state.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getState", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":278
 *         return val
 * 
 *     def setParallel(self, pmode):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the mode of operation in parallel runs.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_31setParallel(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_30setParallel[] = "DS.setParallel(self, pmode)\n\n        Selects the mode of operation in parallel runs.\n\n        Parameters\n        ----------\n        pmode: `DS.ParallelType` enumerate\n               The parallel mode.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_31setParallel(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_pmode = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setParallel (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pmode,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pmode)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setParallel") < 0)) __PYX_ERR(14, 278, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_pmode = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setParallel", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 278, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setParallel", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_30setParallel(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_pmode);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_30setParallel(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_pmode) {
  DSParallelType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  DSParallelType __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setParallel", 0);

  /* "SLEPc/DS.pyx":287
 *                The parallel mode.
 *         """
 *         cdef SlepcDSParallelType val = pmode             # <<<<<<<<<<<<<<
 *         CHKERR( DSSetParallel(self.ds, val) )
 * 
 */
  __pyx_t_1 = ((DSParallelType)__Pyx_PyInt_As_DSParallelType(__pyx_v_pmode)); if (unlikely(PyErr_Occurred())) __PYX_ERR(14, 287, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/DS.pyx":288
 *         """
 *         cdef SlepcDSParallelType val = pmode
 *         CHKERR( DSSetParallel(self.ds, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getParallel(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSSetParallel(__pyx_v_self->ds, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 288, __pyx_L1_error)

  /* "SLEPc/DS.pyx":278
 *         return val
 * 
 *     def setParallel(self, pmode):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the mode of operation in parallel runs.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setParallel", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":290
 *         CHKERR( DSSetParallel(self.ds, val) )
 * 
 *     def getParallel(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the mode of operation in parallel runs.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_33getParallel(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_32getParallel[] = "DS.getParallel(self)\n\n        Gets the mode of operation in parallel runs.\n\n        Returns\n        -------\n        pmode: `DS.ParallelType` enumerate\n               The parallel mode.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_33getParallel(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getParallel (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getParallel", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getParallel", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_32getParallel(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_32getParallel(struct PySlepcDSObject *__pyx_v_self) {
  DSParallelType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getParallel", 0);

  /* "SLEPc/DS.pyx":299
 *                The parallel mode.
 *         """
 *         cdef SlepcDSParallelType val = DS_PARALLEL_REDUNDANT             # <<<<<<<<<<<<<<
 *         CHKERR( DSGetParallel(self.ds, &val) )
 *         return val
 */
  __pyx_v_val = DS_PARALLEL_REDUNDANT;

  /* "SLEPc/DS.pyx":300
 *         """
 *         cdef SlepcDSParallelType val = DS_PARALLEL_REDUNDANT
 *         CHKERR( DSGetParallel(self.ds, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSGetParallel(__pyx_v_self->ds, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 300, __pyx_L1_error)

  /* "SLEPc/DS.pyx":301
 *         cdef SlepcDSParallelType val = DS_PARALLEL_REDUNDANT
 *         CHKERR( DSGetParallel(self.ds, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setDimensions(self, n=None, l=None, k=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_DSParallelType(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 301, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":290
 *         CHKERR( DSSetParallel(self.ds, val) )
 * 
 *     def getParallel(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the mode of operation in parallel runs.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getParallel", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":303
 *         return val
 * 
 *     def setDimensions(self, n=None, l=None, k=None):             # <<<<<<<<<<<<<<
 *         """
 *         Resize the matrices in the DS object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_35setDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_34setDimensions[] = "DS.setDimensions(self, n=None, l=None, k=None)\n\n        Resize the matrices in the DS object.\n\n        Parameters\n        ----------\n        n: int, optional\n           The new size.\n        l: int, optional\n           Number of locked (inactive) leading columns.\n        k: int, optional\n           Intermediate dimension (e.g., position of arrow).\n\n        Notes\n        -----\n        The internal arrays are not reallocated.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_35setDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_n = 0;
  PyObject *__pyx_v_l = 0;
  PyObject *__pyx_v_k = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setDimensions (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_n,&__pyx_n_s_l,&__pyx_n_s_k,0};
    PyObject* values[3] = {0,0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_l);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_k);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setDimensions") < 0)) __PYX_ERR(14, 303, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_n = values[0];
    __pyx_v_l = values[1];
    __pyx_v_k = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setDimensions", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 303, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_34setDimensions(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_n, __pyx_v_l, __pyx_v_k);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_34setDimensions(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_n, PyObject *__pyx_v_l, PyObject *__pyx_v_k) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setDimensions", 0);

  /* "SLEPc/DS.pyx":320
 *         The internal arrays are not reallocated.
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/DS.pyx":321
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival3 = 0
 *         if n is not None: ival1 = asInt(n)
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/DS.pyx":322
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0             # <<<<<<<<<<<<<<
 *         if n is not None: ival1 = asInt(n)
 *         if l is not None: ival2 = asInt(l)
 */
  __pyx_v_ival3 = 0;

  /* "SLEPc/DS.pyx":323
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 *         if n is not None: ival1 = asInt(n)             # <<<<<<<<<<<<<<
 *         if l is not None: ival2 = asInt(l)
 *         if k is not None: ival3 = asInt(k)
 */
  __pyx_t_1 = (__pyx_v_n != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_n); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(14, 323, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_3;
  }

  /* "SLEPc/DS.pyx":324
 *         cdef PetscInt ival3 = 0
 *         if n is not None: ival1 = asInt(n)
 *         if l is not None: ival2 = asInt(l)             # <<<<<<<<<<<<<<
 *         if k is not None: ival3 = asInt(k)
 *         CHKERR( DSSetDimensions(self.ds, ival1, ival2, ival3) )
 */
  __pyx_t_2 = (__pyx_v_l != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_l); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(14, 324, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_3;
  }

  /* "SLEPc/DS.pyx":325
 *         if n is not None: ival1 = asInt(n)
 *         if l is not None: ival2 = asInt(l)
 *         if k is not None: ival3 = asInt(k)             # <<<<<<<<<<<<<<
 *         CHKERR( DSSetDimensions(self.ds, ival1, ival2, ival3) )
 * 
 */
  __pyx_t_1 = (__pyx_v_k != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_k); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(14, 325, __pyx_L1_error)
    __pyx_v_ival3 = __pyx_t_3;
  }

  /* "SLEPc/DS.pyx":326
 *         if l is not None: ival2 = asInt(l)
 *         if k is not None: ival3 = asInt(k)
 *         CHKERR( DSSetDimensions(self.ds, ival1, ival2, ival3) )             # <<<<<<<<<<<<<<
 * 
 *     def getDimensions(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSSetDimensions(__pyx_v_self->ds, __pyx_v_ival1, __pyx_v_ival2, __pyx_v_ival3)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(14, 326, __pyx_L1_error)

  /* "SLEPc/DS.pyx":303
 *         return val
 * 
 *     def setDimensions(self, n=None, l=None, k=None):             # <<<<<<<<<<<<<<
 *         """
 *         Resize the matrices in the DS object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":328
 *         CHKERR( DSSetDimensions(self.ds, ival1, ival2, ival3) )
 * 
 *     def getDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the current dimensions.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_37getDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_36getDimensions[] = "DS.getDimensions(self)\n\n        Returns the current dimensions.\n\n        Returns\n        -------\n        n: int\n           The new size.\n        l: int\n           Number of locked (inactive) leading columns.\n        k: int\n           Intermediate dimension (e.g., position of arrow).\n        t: int\n           Truncated length.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_37getDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDimensions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getDimensions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDimensions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_36getDimensions(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_36getDimensions(struct PySlepcDSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PetscInt __pyx_v_ival4;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getDimensions", 0);

  /* "SLEPc/DS.pyx":343
 *            Truncated length.
 *         """
 *         cdef PetscInt ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/DS.pyx":344
 *         """
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival3 = 0
 *         cdef PetscInt ival4 = 0
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/DS.pyx":345
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival4 = 0
 *         CHKERR( DSGetDimensions(self.ds, &ival1, &ival2, &ival3, &ival4) )
 */
  __pyx_v_ival3 = 0;

  /* "SLEPc/DS.pyx":346
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 *         cdef PetscInt ival4 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( DSGetDimensions(self.ds, &ival1, &ival2, &ival3, &ival4) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4))
 */
  __pyx_v_ival4 = 0;

  /* "SLEPc/DS.pyx":347
 *         cdef PetscInt ival3 = 0
 *         cdef PetscInt ival4 = 0
 *         CHKERR( DSGetDimensions(self.ds, &ival1, &ival2, &ival3, &ival4) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSGetDimensions(__pyx_v_self->ds, (&__pyx_v_ival1), (&__pyx_v_ival2), (&__pyx_v_ival3), (&__pyx_v_ival4))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 347, __pyx_L1_error)

  /* "SLEPc/DS.pyx":348
 *         cdef PetscInt ival4 = 0
 *         CHKERR( DSGetDimensions(self.ds, &ival1, &ival2, &ival3, &ival4) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4))             # <<<<<<<<<<<<<<
 * 
 *     def setBlockSize(self, bs):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival3); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival4); if (unlikely(!__pyx_t_5)) __PYX_ERR(14, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(14, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_5);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_r = __pyx_t_6;
  __pyx_t_6 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":328
 *         CHKERR( DSSetDimensions(self.ds, ival1, ival2, ival3) )
 * 
 *     def getDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the current dimensions.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":350
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4))
 * 
 *     def setBlockSize(self, bs):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the block size.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_39setBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_38setBlockSize[] = "DS.setBlockSize(self, bs)\n\n        Selects the block size.\n\n        Parameters\n        ----------\n        bs: int\n            The block size.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_39setBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_bs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setBlockSize (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bs,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bs)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setBlockSize") < 0)) __PYX_ERR(14, 350, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_bs = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setBlockSize", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 350, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setBlockSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_38setBlockSize(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_bs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_38setBlockSize(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_bs) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setBlockSize", 0);

  /* "SLEPc/DS.pyx":359
 *             The block size.
 *         """
 *         cdef PetscInt val = bs             # <<<<<<<<<<<<<<
 *         CHKERR( DSSetBlockSize(self.ds, val) )
 * 
 */
  __pyx_t_1 = __Pyx_PyInt_As_PetscInt(__pyx_v_bs); if (unlikely((__pyx_t_1 == ((PetscInt)-1)) && PyErr_Occurred())) __PYX_ERR(14, 359, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/DS.pyx":360
 *         """
 *         cdef PetscInt val = bs
 *         CHKERR( DSSetBlockSize(self.ds, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getBlockSize(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSSetBlockSize(__pyx_v_self->ds, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 360, __pyx_L1_error)

  /* "SLEPc/DS.pyx":350
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4))
 * 
 *     def setBlockSize(self, bs):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the block size.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setBlockSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":362
 *         CHKERR( DSSetBlockSize(self.ds, val) )
 * 
 *     def getBlockSize(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the block size.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_41getBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_40getBlockSize[] = "DS.getBlockSize(self)\n\n        Gets the block size.\n\n        Returns\n        -------\n        bs: int\n            The block size.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_41getBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getBlockSize (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getBlockSize", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBlockSize", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_40getBlockSize(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_40getBlockSize(struct PySlepcDSObject *__pyx_v_self) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getBlockSize", 0);

  /* "SLEPc/DS.pyx":371
 *             The block size.
 *         """
 *         cdef PetscInt val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( DSGetBlockSize(self.ds, &val) )
 *         return val
 */
  __pyx_v_val = 0;

  /* "SLEPc/DS.pyx":372
 *         """
 *         cdef PetscInt val = 0
 *         CHKERR( DSGetBlockSize(self.ds, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSGetBlockSize(__pyx_v_self->ds, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 372, __pyx_L1_error)

  /* "SLEPc/DS.pyx":373
 *         cdef PetscInt val = 0
 *         CHKERR( DSGetBlockSize(self.ds, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setMethod(self, meth):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_PetscInt(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 373, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":362
 *         CHKERR( DSSetBlockSize(self.ds, val) )
 * 
 *     def getBlockSize(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the block size.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getBlockSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":375
 *         return val
 * 
 *     def setMethod(self, meth):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the method to be used to solve the problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_43setMethod(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_42setMethod[] = "DS.setMethod(self, meth)\n\n        Selects the method to be used to solve the problem.\n\n        Parameters\n        ----------\n        meth: int\n              An index identifying the method.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_43setMethod(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_meth = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setMethod (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_meth,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_meth)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setMethod") < 0)) __PYX_ERR(14, 375, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_meth = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setMethod", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 375, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setMethod", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_42setMethod(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_meth);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_42setMethod(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_meth) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setMethod", 0);

  /* "SLEPc/DS.pyx":384
 *               An index identifying the method.
 *         """
 *         cdef PetscInt val = meth             # <<<<<<<<<<<<<<
 *         CHKERR( DSSetMethod(self.ds, val) )
 * 
 */
  __pyx_t_1 = __Pyx_PyInt_As_PetscInt(__pyx_v_meth); if (unlikely((__pyx_t_1 == ((PetscInt)-1)) && PyErr_Occurred())) __PYX_ERR(14, 384, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/DS.pyx":385
 *         """
 *         cdef PetscInt val = meth
 *         CHKERR( DSSetMethod(self.ds, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getMethod(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSSetMethod(__pyx_v_self->ds, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 385, __pyx_L1_error)

  /* "SLEPc/DS.pyx":375
 *         return val
 * 
 *     def setMethod(self, meth):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the method to be used to solve the problem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setMethod", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":387
 *         CHKERR( DSSetMethod(self.ds, val) )
 * 
 *     def getMethod(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the method currently used in the DS.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_45getMethod(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_44getMethod[] = "DS.getMethod(self)\n\n        Gets the method currently used in the DS.\n\n        Returns\n        -------\n        meth: int\n              Identifier of the method.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_45getMethod(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getMethod (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getMethod", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getMethod", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_44getMethod(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_44getMethod(struct PySlepcDSObject *__pyx_v_self) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getMethod", 0);

  /* "SLEPc/DS.pyx":396
 *               Identifier of the method.
 *         """
 *         cdef PetscInt val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( DSGetMethod(self.ds, &val) )
 *         return val
 */
  __pyx_v_val = 0;

  /* "SLEPc/DS.pyx":397
 *         """
 *         cdef PetscInt val = 0
 *         CHKERR( DSGetMethod(self.ds, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSGetMethod(__pyx_v_self->ds, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 397, __pyx_L1_error)

  /* "SLEPc/DS.pyx":398
 *         cdef PetscInt val = 0
 *         CHKERR( DSGetMethod(self.ds, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setCompact(self, comp):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_PetscInt(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 398, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":387
 *         CHKERR( DSSetMethod(self.ds, val) )
 * 
 *     def getMethod(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the method currently used in the DS.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getMethod", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":400
 *         return val
 * 
 *     def setCompact(self, comp):             # <<<<<<<<<<<<<<
 *         """
 *         Switch to compact storage of matrices.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_47setCompact(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_46setCompact[] = "DS.setCompact(self, comp)\n\n        Switch to compact storage of matrices.\n\n        Parameters\n        ----------\n        comp: bool\n              True means compact storage.\n\n        Notes\n        -----\n        Compact storage is used in some `DS` types such as\n        `DS.Type.HEP` when the matrix is tridiagonal. This flag\n        can be used to indicate whether the user provides the\n        matrix entries via the compact form (the tridiagonal\n        `DS.MatType.T`) or the non-compact one (`DS.MatType.A`).\n\n        The default is ``False``.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_47setCompact(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comp = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCompact (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comp,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comp)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCompact") < 0)) __PYX_ERR(14, 400, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_comp = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCompact", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 400, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setCompact", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_46setCompact(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_comp);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_46setCompact(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_comp) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCompact", 0);

  /* "SLEPc/DS.pyx":419
 *         The default is ``False``.
 *         """
 *         cdef PetscBool val = asBool(comp)             # <<<<<<<<<<<<<<
 *         CHKERR( DSSetCompact(self.ds, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_comp); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(14, 419, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/DS.pyx":420
 *         """
 *         cdef PetscBool val = asBool(comp)
 *         CHKERR( DSSetCompact(self.ds, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getCompact(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSSetCompact(__pyx_v_self->ds, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 420, __pyx_L1_error)

  /* "SLEPc/DS.pyx":400
 *         return val
 * 
 *     def setCompact(self, comp):             # <<<<<<<<<<<<<<
 *         """
 *         Switch to compact storage of matrices.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setCompact", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":422
 *         CHKERR( DSSetCompact(self.ds, val) )
 * 
 *     def getCompact(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the compact storage flag.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_49getCompact(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_48getCompact[] = "DS.getCompact(self)\n\n        Gets the compact storage flag.\n\n        Returns\n        -------\n        comp: bool\n              The flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_49getCompact(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCompact (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCompact", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCompact", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_48getCompact(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_48getCompact(struct PySlepcDSObject *__pyx_v_self) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCompact", 0);

  /* "SLEPc/DS.pyx":431
 *               The flag.
 *         """
 *         cdef PetscBool val = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( DSGetCompact(self.ds, &val) )
 *         return toBool(val)
 */
  __pyx_v_val = PETSC_FALSE;

  /* "SLEPc/DS.pyx":432
 *         """
 *         cdef PetscBool val = PETSC_FALSE
 *         CHKERR( DSGetCompact(self.ds, &val) )             # <<<<<<<<<<<<<<
 *         return toBool(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSGetCompact(__pyx_v_self->ds, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 432, __pyx_L1_error)

  /* "SLEPc/DS.pyx":433
 *         cdef PetscBool val = PETSC_FALSE
 *         CHKERR( DSGetCompact(self.ds, &val) )
 *         return toBool(val)             # <<<<<<<<<<<<<<
 * 
 *     def setExtraRow(self, ext):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 433, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":422
 *         CHKERR( DSSetCompact(self.ds, val) )
 * 
 *     def getCompact(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the compact storage flag.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getCompact", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":435
 *         return toBool(val)
 * 
 *     def setExtraRow(self, ext):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to indicate that the matrix has one extra row.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_51setExtraRow(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_50setExtraRow[] = "DS.setExtraRow(self, ext)\n\n        Sets a flag to indicate that the matrix has one extra row.\n\n        Parameters\n        ----------\n        ext: bool\n             True if the matrix has extra row.\n\n        Notes\n        -----\n        In Krylov methods it is useful that the matrix representing\n        the direct solver has one extra row, i.e., has dimension\n        (n+1)*n . If this flag is activated, all transformations\n        applied to the right of the matrix also affect this additional\n        row. In that case, (n+1) must be less or equal than the\n        leading dimension.\n\n        The default is ``False``.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_51setExtraRow(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_ext = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setExtraRow (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ext,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ext)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setExtraRow") < 0)) __PYX_ERR(14, 435, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_ext = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setExtraRow", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 435, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setExtraRow", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_50setExtraRow(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_ext);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_50setExtraRow(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_ext) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setExtraRow", 0);

  /* "SLEPc/DS.pyx":455
 *         The default is ``False``.
 *         """
 *         cdef PetscBool val = asBool(ext)             # <<<<<<<<<<<<<<
 *         CHKERR( DSSetExtraRow(self.ds, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_ext); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(14, 455, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/DS.pyx":456
 *         """
 *         cdef PetscBool val = asBool(ext)
 *         CHKERR( DSSetExtraRow(self.ds, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getExtraRow(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSSetExtraRow(__pyx_v_self->ds, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 456, __pyx_L1_error)

  /* "SLEPc/DS.pyx":435
 *         return toBool(val)
 * 
 *     def setExtraRow(self, ext):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to indicate that the matrix has one extra row.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setExtraRow", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":458
 *         CHKERR( DSSetExtraRow(self.ds, val) )
 * 
 *     def getExtraRow(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the extra row flag.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_53getExtraRow(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_52getExtraRow[] = "DS.getExtraRow(self)\n\n        Gets the extra row flag.\n\n        Returns\n        -------\n        comp: bool\n              The flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_53getExtraRow(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getExtraRow (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getExtraRow", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getExtraRow", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_52getExtraRow(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_52getExtraRow(struct PySlepcDSObject *__pyx_v_self) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getExtraRow", 0);

  /* "SLEPc/DS.pyx":467
 *               The flag.
 *         """
 *         cdef PetscBool val = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( DSGetExtraRow(self.ds, &val) )
 *         return toBool(val)
 */
  __pyx_v_val = PETSC_FALSE;

  /* "SLEPc/DS.pyx":468
 *         """
 *         cdef PetscBool val = PETSC_FALSE
 *         CHKERR( DSGetExtraRow(self.ds, &val) )             # <<<<<<<<<<<<<<
 *         return toBool(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSGetExtraRow(__pyx_v_self->ds, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 468, __pyx_L1_error)

  /* "SLEPc/DS.pyx":469
 *         cdef PetscBool val = PETSC_FALSE
 *         CHKERR( DSGetExtraRow(self.ds, &val) )
 *         return toBool(val)             # <<<<<<<<<<<<<<
 * 
 *     def setRefined(self, ref):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 469, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":458
 *         CHKERR( DSSetExtraRow(self.ds, val) )
 * 
 *     def getExtraRow(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the extra row flag.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getExtraRow", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":471
 *         return toBool(val)
 * 
 *     def setRefined(self, ref):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to indicate that refined vectors must be computed.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_55setRefined(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_54setRefined[] = "DS.setRefined(self, ref)\n\n        Sets a flag to indicate that refined vectors must be computed.\n\n        Parameters\n        ----------\n        ref: bool\n             True if refined vectors must be used.\n\n        Notes\n        -----\n        Normally the vectors returned in `DS.MatType.X` are eigenvectors\n        of the projected matrix. With this flag activated, `vectors()`\n        will return the right singular vector of the smallest singular\n        value of matrix At-theta*I, where At is the extended (n+1)xn\n        matrix and theta is the Ritz value. This is used in the\n        refined Ritz approximation.\n\n        The default is ``False``.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_55setRefined(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_ref = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRefined (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ref,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ref)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRefined") < 0)) __PYX_ERR(14, 471, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_ref = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRefined", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 471, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setRefined", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_54setRefined(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_ref);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_54setRefined(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_ref) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRefined", 0);

  /* "SLEPc/DS.pyx":491
 *         The default is ``False``.
 *         """
 *         cdef PetscBool val = asBool(ref)             # <<<<<<<<<<<<<<
 *         CHKERR( DSSetRefined(self.ds, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_ref); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(14, 491, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/DS.pyx":492
 *         """
 *         cdef PetscBool val = asBool(ref)
 *         CHKERR( DSSetRefined(self.ds, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getRefined(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSSetRefined(__pyx_v_self->ds, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 492, __pyx_L1_error)

  /* "SLEPc/DS.pyx":471
 *         return toBool(val)
 * 
 *     def setRefined(self, ref):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to indicate that refined vectors must be computed.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setRefined", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":494
 *         CHKERR( DSSetRefined(self.ds, val) )
 * 
 *     def getRefined(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the refined vectors flag.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_57getRefined(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_56getRefined[] = "DS.getRefined(self)\n\n        Gets the refined vectors flag.\n\n        Returns\n        -------\n        comp: bool\n              The flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_57getRefined(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRefined (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRefined", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRefined", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_56getRefined(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_56getRefined(struct PySlepcDSObject *__pyx_v_self) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRefined", 0);

  /* "SLEPc/DS.pyx":503
 *               The flag.
 *         """
 *         cdef PetscBool val = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( DSGetRefined(self.ds, &val) )
 *         return toBool(val)
 */
  __pyx_v_val = PETSC_FALSE;

  /* "SLEPc/DS.pyx":504
 *         """
 *         cdef PetscBool val = PETSC_FALSE
 *         CHKERR( DSGetRefined(self.ds, &val) )             # <<<<<<<<<<<<<<
 *         return toBool(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSGetRefined(__pyx_v_self->ds, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 504, __pyx_L1_error)

  /* "SLEPc/DS.pyx":505
 *         cdef PetscBool val = PETSC_FALSE
 *         CHKERR( DSGetRefined(self.ds, &val) )
 *         return toBool(val)             # <<<<<<<<<<<<<<
 * 
 *     def truncate(self, n, trim=False):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 505, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":494
 *         CHKERR( DSSetRefined(self.ds, val) )
 * 
 *     def getRefined(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the refined vectors flag.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getRefined", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":507
 *         return toBool(val)
 * 
 *     def truncate(self, n, trim=False):             # <<<<<<<<<<<<<<
 *         """
 *         Truncates the system represented in the DS object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_59truncate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_58truncate[] = "DS.truncate(self, n, trim=False)\n\n        Truncates the system represented in the DS object.\n\n        Parameters\n        ----------\n        n: int\n           The new size.\n        trim: bool, optional\n              A flag to indicate if the factorization must be trimmed.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_59truncate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_n = 0;
  PyObject *__pyx_v_trim = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("truncate (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_n,&__pyx_n_s_trim,0};
    PyObject* values[2] = {0,0};
    values[1] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_trim);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "truncate") < 0)) __PYX_ERR(14, 507, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_n = values[0];
    __pyx_v_trim = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("truncate", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 507, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.truncate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_58truncate(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_n, __pyx_v_trim);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_58truncate(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_n, PyObject *__pyx_v_trim) {
  PetscInt __pyx_v_val;
  PetscBool __pyx_v_flg;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  PetscBool __pyx_t_2;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("truncate", 0);

  /* "SLEPc/DS.pyx":518
 *               A flag to indicate if the factorization must be trimmed.
 *         """
 *         cdef PetscInt val = asInt(n)             # <<<<<<<<<<<<<<
 *         cdef PetscBool flg = asBool(trim)
 *         CHKERR( DSTruncate(self.ds, val, flg) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_n); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(14, 518, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/DS.pyx":519
 *         """
 *         cdef PetscInt val = asInt(n)
 *         cdef PetscBool flg = asBool(trim)             # <<<<<<<<<<<<<<
 *         CHKERR( DSTruncate(self.ds, val, flg) )
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_trim); if (unlikely(__pyx_t_2 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(14, 519, __pyx_L1_error)
  __pyx_v_flg = __pyx_t_2;

  /* "SLEPc/DS.pyx":520
 *         cdef PetscInt val = asInt(n)
 *         cdef PetscBool flg = asBool(trim)
 *         CHKERR( DSTruncate(self.ds, val, flg) )             # <<<<<<<<<<<<<<
 * 
 *     def updateExtraRow(self):
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSTruncate(__pyx_v_self->ds, __pyx_v_val, __pyx_v_flg)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(14, 520, __pyx_L1_error)

  /* "SLEPc/DS.pyx":507
 *         return toBool(val)
 * 
 *     def truncate(self, n, trim=False):             # <<<<<<<<<<<<<<
 *         """
 *         Truncates the system represented in the DS object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.truncate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":522
 *         CHKERR( DSTruncate(self.ds, val, flg) )
 * 
 *     def updateExtraRow(self):             # <<<<<<<<<<<<<<
 *         """
 *         Performs all necessary operations so that the extra
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_61updateExtraRow(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_60updateExtraRow[] = "DS.updateExtraRow(self)\n\n        Performs all necessary operations so that the extra\n        row gets up-to-date after a call to `solve()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_61updateExtraRow(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("updateExtraRow (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("updateExtraRow", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "updateExtraRow", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_60updateExtraRow(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_60updateExtraRow(struct PySlepcDSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("updateExtraRow", 0);

  /* "SLEPc/DS.pyx":527
 *         row gets up-to-date after a call to `solve()`.
 *         """
 *         CHKERR( DSUpdateExtraRow(self.ds) )             # <<<<<<<<<<<<<<
 * 
 *     def getMat(self, matname):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSUpdateExtraRow(__pyx_v_self->ds)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 527, __pyx_L1_error)

  /* "SLEPc/DS.pyx":522
 *         CHKERR( DSTruncate(self.ds, val, flg) )
 * 
 *     def updateExtraRow(self):             # <<<<<<<<<<<<<<
 *         """
 *         Performs all necessary operations so that the extra
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.updateExtraRow", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":529
 *         CHKERR( DSUpdateExtraRow(self.ds) )
 * 
 *     def getMat(self, matname):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the requested matrix as a sequential dense Mat object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_63getMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_62getMat[] = "DS.getMat(self, matname)\n\n        Returns the requested matrix as a sequential dense Mat object.\n\n        Parameters\n        ----------\n        matname: `DS.MatType` enumerate\n           The requested matrix.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_63getMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_matname = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getMat (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_matname,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_matname)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getMat") < 0)) __PYX_ERR(14, 529, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_matname = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getMat", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 529, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_62getMat(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_matname);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_62getMat(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_matname) {
  DSMatType __pyx_v_mname;
  struct PyPetscMatObject *__pyx_v_mat = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  DSMatType __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getMat", 0);

  /* "SLEPc/DS.pyx":538
 *            The requested matrix.
 *         """
 *         cdef SlepcDSMatType mname = matname             # <<<<<<<<<<<<<<
 *         cdef Mat mat = Mat()
 *         CHKERR( DSGetMat(self.ds, mname, &mat.mat) )
 */
  __pyx_t_1 = ((DSMatType)__Pyx_PyInt_As_DSMatType(__pyx_v_matname)); if (unlikely(PyErr_Occurred())) __PYX_ERR(14, 538, __pyx_L1_error)
  __pyx_v_mname = __pyx_t_1;

  /* "SLEPc/DS.pyx":539
 *         """
 *         cdef SlepcDSMatType mname = matname
 *         cdef Mat mat = Mat()             # <<<<<<<<<<<<<<
 *         CHKERR( DSGetMat(self.ds, mname, &mat.mat) )
 *         PetscINCREF(mat.obj)
 */
  __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 539, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_mat = ((struct PyPetscMatObject *)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/DS.pyx":540
 *         cdef SlepcDSMatType mname = matname
 *         cdef Mat mat = Mat()
 *         CHKERR( DSGetMat(self.ds, mname, &mat.mat) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(mat.obj)
 *         return mat
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSGetMat(__pyx_v_self->ds, __pyx_v_mname, (&__pyx_v_mat->mat))); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(14, 540, __pyx_L1_error)

  /* "SLEPc/DS.pyx":541
 *         cdef Mat mat = Mat()
 *         CHKERR( DSGetMat(self.ds, mname, &mat.mat) )
 *         PetscINCREF(mat.obj)             # <<<<<<<<<<<<<<
 *         return mat
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_mat->__pyx_base.obj));

  /* "SLEPc/DS.pyx":542
 *         CHKERR( DSGetMat(self.ds, mname, &mat.mat) )
 *         PetscINCREF(mat.obj)
 *         return mat             # <<<<<<<<<<<<<<
 * 
 *     def restoreMat(self, matname, Mat mat):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_mat));
  __pyx_r = ((PyObject *)__pyx_v_mat);
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":529
 *         CHKERR( DSUpdateExtraRow(self.ds) )
 * 
 *     def getMat(self, matname):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the requested matrix as a sequential dense Mat object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_mat);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":544
 *         return mat
 * 
 *     def restoreMat(self, matname, Mat mat):             # <<<<<<<<<<<<<<
 *         """
 *         Restore the previously seized matrix.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_65restoreMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_64restoreMat[] = "DS.restoreMat(self, matname, Mat mat)\n\n        Restore the previously seized matrix.\n\n        Parameters\n        ----------\n        matname: `DS.MatType` enumerate\n           The selected matrix.\n        mat: Mat\n           The matrix previously obtained with `getMat()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_65restoreMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_matname = 0;
  struct PyPetscMatObject *__pyx_v_mat = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("restoreMat (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_matname,&__pyx_n_s_mat,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_matname)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mat)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("restoreMat", 1, 2, 2, 1); __PYX_ERR(14, 544, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "restoreMat") < 0)) __PYX_ERR(14, 544, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_matname = values[0];
    __pyx_v_mat = ((struct PyPetscMatObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("restoreMat", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 544, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.restoreMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_mat), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "mat", 0))) __PYX_ERR(14, 544, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_64restoreMat(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_matname, __pyx_v_mat);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_64restoreMat(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_matname, struct PyPetscMatObject *__pyx_v_mat) {
  DSMatType __pyx_v_mname;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  DSMatType __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("restoreMat", 0);

  /* "SLEPc/DS.pyx":555
 *            The matrix previously obtained with `getMat()`.
 *         """
 *         cdef SlepcDSMatType mname = matname             # <<<<<<<<<<<<<<
 *         CHKERR( PetscObjectDereference(<PetscObject>mat.mat) )
 *         CHKERR( DSRestoreMat(self.ds, mname, &mat.mat) )
 */
  __pyx_t_1 = ((DSMatType)__Pyx_PyInt_As_DSMatType(__pyx_v_matname)); if (unlikely(PyErr_Occurred())) __PYX_ERR(14, 555, __pyx_L1_error)
  __pyx_v_mname = __pyx_t_1;

  /* "SLEPc/DS.pyx":556
 *         """
 *         cdef SlepcDSMatType mname = matname
 *         CHKERR( PetscObjectDereference(<PetscObject>mat.mat) )             # <<<<<<<<<<<<<<
 *         CHKERR( DSRestoreMat(self.ds, mname, &mat.mat) )
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscObjectDereference(((PetscObject)__pyx_v_mat->mat))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 556, __pyx_L1_error)

  /* "SLEPc/DS.pyx":557
 *         cdef SlepcDSMatType mname = matname
 *         CHKERR( PetscObjectDereference(<PetscObject>mat.mat) )
 *         CHKERR( DSRestoreMat(self.ds, mname, &mat.mat) )             # <<<<<<<<<<<<<<
 * 
 *     def setIdentity(self, matname):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSRestoreMat(__pyx_v_self->ds, __pyx_v_mname, (&__pyx_v_mat->mat))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 557, __pyx_L1_error)

  /* "SLEPc/DS.pyx":544
 *         return mat
 * 
 *     def restoreMat(self, matname, Mat mat):             # <<<<<<<<<<<<<<
 *         """
 *         Restore the previously seized matrix.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.restoreMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":559
 *         CHKERR( DSRestoreMat(self.ds, mname, &mat.mat) )
 * 
 *     def setIdentity(self, matname):             # <<<<<<<<<<<<<<
 *         """
 *         Copy the identity on the active part of a matrix.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_67setIdentity(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_66setIdentity[] = "DS.setIdentity(self, matname)\n\n        Copy the identity on the active part of a matrix.\n\n        Parameters\n        ----------\n        matname: `DS.MatType` enumerate\n           The requested matrix.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_67setIdentity(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_matname = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setIdentity (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_matname,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_matname)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setIdentity") < 0)) __PYX_ERR(14, 559, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_matname = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setIdentity", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 559, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setIdentity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_66setIdentity(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_matname);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_66setIdentity(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_matname) {
  DSMatType __pyx_v_mname;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  DSMatType __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setIdentity", 0);

  /* "SLEPc/DS.pyx":568
 *            The requested matrix.
 *         """
 *         cdef SlepcDSMatType mname = matname             # <<<<<<<<<<<<<<
 *         CHKERR( DSSetIdentity(self.ds, mname) )
 * 
 */
  __pyx_t_1 = ((DSMatType)__Pyx_PyInt_As_DSMatType(__pyx_v_matname)); if (unlikely(PyErr_Occurred())) __PYX_ERR(14, 568, __pyx_L1_error)
  __pyx_v_mname = __pyx_t_1;

  /* "SLEPc/DS.pyx":569
 *         """
 *         cdef SlepcDSMatType mname = matname
 *         CHKERR( DSSetIdentity(self.ds, mname) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSSetIdentity(__pyx_v_self->ds, __pyx_v_mname)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 569, __pyx_L1_error)

  /* "SLEPc/DS.pyx":559
 *         CHKERR( DSRestoreMat(self.ds, mname, &mat.mat) )
 * 
 *     def setIdentity(self, matname):             # <<<<<<<<<<<<<<
 *         """
 *         Copy the identity on the active part of a matrix.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setIdentity", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":573
 *     #
 * 
 *     def cond(self):             # <<<<<<<<<<<<<<
 *         """
 *         Compute the inf-norm condition number of the first matrix.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_69cond(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_68cond[] = "DS.cond(self)\n\n        Compute the inf-norm condition number of the first matrix.\n\n        Returns\n        -------\n        cond: real\n            Condition number.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_69cond(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("cond (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("cond", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "cond", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_68cond(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_68cond(struct PySlepcDSObject *__pyx_v_self) {
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("cond", 0);

  /* "SLEPc/DS.pyx":582
 *             Condition number.
 *         """
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( DSCond(self.ds, &rval) )
 *         return toReal(rval)
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/DS.pyx":583
 *         """
 *         cdef PetscReal rval = 0
 *         CHKERR( DSCond(self.ds, &rval) )             # <<<<<<<<<<<<<<
 *         return toReal(rval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSCond(__pyx_v_self->ds, (&__pyx_v_rval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 583, __pyx_L1_error)

  /* "SLEPc/DS.pyx":584
 *         cdef PetscReal rval = 0
 *         CHKERR( DSCond(self.ds, &rval) )
 *         return toReal(rval)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 584, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":573
 *     #
 * 
 *     def cond(self):             # <<<<<<<<<<<<<<
 *         """
 *         Compute the inf-norm condition number of the first matrix.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.cond", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":588
 *     #
 * 
 *     def setSVDDimensions(self, m):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of columns of a `DS` of type `SVD`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_71setSVDDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_70setSVDDimensions[] = "DS.setSVDDimensions(self, m)\n\n        Sets the number of columns of a `DS` of type `SVD`.\n\n        Parameters\n        ----------\n        m: int\n           The number of columns.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_71setSVDDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_m = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSVDDimensions (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_m,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_m)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSVDDimensions") < 0)) __PYX_ERR(14, 588, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_m = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSVDDimensions", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 588, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setSVDDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_70setSVDDimensions(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_m);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_70setSVDDimensions(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_m) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSVDDimensions", 0);

  /* "SLEPc/DS.pyx":597
 *            The number of columns.
 *         """
 *         cdef PetscInt val = asInt(m)             # <<<<<<<<<<<<<<
 *         CHKERR( DSSVDSetDimensions(self.ds, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_m); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(14, 597, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/DS.pyx":598
 *         """
 *         cdef PetscInt val = asInt(m)
 *         CHKERR( DSSVDSetDimensions(self.ds, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getSVDDimensions(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSSVDSetDimensions(__pyx_v_self->ds, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 598, __pyx_L1_error)

  /* "SLEPc/DS.pyx":588
 *     #
 * 
 *     def setSVDDimensions(self, m):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of columns of a `DS` of type `SVD`.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setSVDDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":600
 *         CHKERR( DSSVDSetDimensions(self.ds, val) )
 * 
 *     def getSVDDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of columns of a `DS` of type `SVD`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_73getSVDDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_72getSVDDimensions[] = "DS.getSVDDimensions(self)\n\n        Gets the number of columns of a `DS` of type `SVD`.\n\n        Returns\n        -------\n        m: int\n           The number of columns.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_73getSVDDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSVDDimensions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSVDDimensions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSVDDimensions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_72getSVDDimensions(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_72getSVDDimensions(struct PySlepcDSObject *__pyx_v_self) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSVDDimensions", 0);

  /* "SLEPc/DS.pyx":609
 *            The number of columns.
 *         """
 *         cdef PetscInt val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( DSSVDGetDimensions(self.ds, &val) )
 *         return toInt(val)
 */
  __pyx_v_val = 0;

  /* "SLEPc/DS.pyx":610
 *         """
 *         cdef PetscInt val = 0
 *         CHKERR( DSSVDGetDimensions(self.ds, &val) )             # <<<<<<<<<<<<<<
 *         return toInt(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSSVDGetDimensions(__pyx_v_self->ds, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 610, __pyx_L1_error)

  /* "SLEPc/DS.pyx":611
 *         cdef PetscInt val = 0
 *         CHKERR( DSSVDGetDimensions(self.ds, &val) )
 *         return toInt(val)             # <<<<<<<<<<<<<<
 * 
 *     def setGSVDDimensions(self, m, p):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 611, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":600
 *         CHKERR( DSSVDSetDimensions(self.ds, val) )
 * 
 *     def getSVDDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of columns of a `DS` of type `SVD`.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getSVDDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":613
 *         return toInt(val)
 * 
 *     def setGSVDDimensions(self, m, p):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of columns and rows of a `DS` of type `GSVD`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_75setGSVDDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_74setGSVDDimensions[] = "DS.setGSVDDimensions(self, m, p)\n\n        Sets the number of columns and rows of a `DS` of type `GSVD`.\n\n        Parameters\n        ----------\n        m: int\n           The number of columns.\n        p: int\n           The number of rows for the second matrix.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_75setGSVDDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_m = 0;
  PyObject *__pyx_v_p = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setGSVDDimensions (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_m,&__pyx_n_s_p,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_m)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_p)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setGSVDDimensions", 1, 2, 2, 1); __PYX_ERR(14, 613, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setGSVDDimensions") < 0)) __PYX_ERR(14, 613, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_m = values[0];
    __pyx_v_p = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setGSVDDimensions", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 613, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setGSVDDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_74setGSVDDimensions(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_m, __pyx_v_p);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_74setGSVDDimensions(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_m, PyObject *__pyx_v_p) {
  PetscInt __pyx_v_val1;
  PetscInt __pyx_v_val2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setGSVDDimensions", 0);

  /* "SLEPc/DS.pyx":624
 *            The number of rows for the second matrix.
 *         """
 *         cdef PetscInt val1 = asInt(m)             # <<<<<<<<<<<<<<
 *         cdef PetscInt val2 = asInt(p)
 *         CHKERR( DSGSVDSetDimensions(self.ds, val1, val2) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_m); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(14, 624, __pyx_L1_error)
  __pyx_v_val1 = __pyx_t_1;

  /* "SLEPc/DS.pyx":625
 *         """
 *         cdef PetscInt val1 = asInt(m)
 *         cdef PetscInt val2 = asInt(p)             # <<<<<<<<<<<<<<
 *         CHKERR( DSGSVDSetDimensions(self.ds, val1, val2) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_p); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(14, 625, __pyx_L1_error)
  __pyx_v_val2 = __pyx_t_1;

  /* "SLEPc/DS.pyx":626
 *         cdef PetscInt val1 = asInt(m)
 *         cdef PetscInt val2 = asInt(p)
 *         CHKERR( DSGSVDSetDimensions(self.ds, val1, val2) )             # <<<<<<<<<<<<<<
 * 
 *     def getGSVDDimensions(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSGSVDSetDimensions(__pyx_v_self->ds, __pyx_v_val1, __pyx_v_val2)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 626, __pyx_L1_error)

  /* "SLEPc/DS.pyx":613
 *         return toInt(val)
 * 
 *     def setGSVDDimensions(self, m, p):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of columns and rows of a `DS` of type `GSVD`.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setGSVDDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":628
 *         CHKERR( DSGSVDSetDimensions(self.ds, val1, val2) )
 * 
 *     def getGSVDDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of columns and rows of a `DS` of type `GSVD`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_77getGSVDDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_76getGSVDDimensions[] = "DS.getGSVDDimensions(self)\n\n        Gets the number of columns and rows of a `DS` of type `GSVD`.\n\n        Returns\n        -------\n        m: int\n           The number of columns.\n        p: int\n           The number of rows for the second matrix.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_77getGSVDDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getGSVDDimensions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getGSVDDimensions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getGSVDDimensions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_76getGSVDDimensions(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_76getGSVDDimensions(struct PySlepcDSObject *__pyx_v_self) {
  PetscInt __pyx_v_val1;
  PetscInt __pyx_v_val2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getGSVDDimensions", 0);

  /* "SLEPc/DS.pyx":639
 *            The number of rows for the second matrix.
 *         """
 *         cdef PetscInt val1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt val2 = 0
 *         CHKERR( DSGSVDGetDimensions(self.ds, &val1, &val2) )
 */
  __pyx_v_val1 = 0;

  /* "SLEPc/DS.pyx":640
 *         """
 *         cdef PetscInt val1 = 0
 *         cdef PetscInt val2 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( DSGSVDGetDimensions(self.ds, &val1, &val2) )
 *         return (toInt(val1), toInt(val2))
 */
  __pyx_v_val2 = 0;

  /* "SLEPc/DS.pyx":641
 *         cdef PetscInt val1 = 0
 *         cdef PetscInt val2 = 0
 *         CHKERR( DSGSVDGetDimensions(self.ds, &val1, &val2) )             # <<<<<<<<<<<<<<
 *         return (toInt(val1), toInt(val2))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSGSVDGetDimensions(__pyx_v_self->ds, (&__pyx_v_val1), (&__pyx_v_val2))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 641, __pyx_L1_error)

  /* "SLEPc/DS.pyx":642
 *         cdef PetscInt val2 = 0
 *         CHKERR( DSGSVDGetDimensions(self.ds, &val1, &val2) )
 *         return (toInt(val1), toInt(val2))             # <<<<<<<<<<<<<<
 * 
 *     def setPEPDegree(self, deg):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_val1); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 642, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_val2); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 642, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 642, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":628
 *         CHKERR( DSGSVDSetDimensions(self.ds, val1, val2) )
 * 
 *     def getGSVDDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of columns and rows of a `DS` of type `GSVD`.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getGSVDDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":644
 *         return (toInt(val1), toInt(val2))
 * 
 *     def setPEPDegree(self, deg):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the polynomial degree of a `DS` of type `PEP`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_79setPEPDegree(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_78setPEPDegree[] = "DS.setPEPDegree(self, deg)\n\n        Sets the polynomial degree of a `DS` of type `PEP`.\n\n        Parameters\n        ----------\n        deg: int\n             The polynomial degree.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_79setPEPDegree(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_deg = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setPEPDegree (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_deg,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_deg)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setPEPDegree") < 0)) __PYX_ERR(14, 644, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_deg = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setPEPDegree", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 644, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setPEPDegree", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_78setPEPDegree(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_deg);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_78setPEPDegree(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_deg) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setPEPDegree", 0);

  /* "SLEPc/DS.pyx":653
 *              The polynomial degree.
 *         """
 *         cdef PetscInt val = asInt(deg)             # <<<<<<<<<<<<<<
 *         CHKERR( DSPEPSetDegree(self.ds, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_deg); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(14, 653, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/DS.pyx":654
 *         """
 *         cdef PetscInt val = asInt(deg)
 *         CHKERR( DSPEPSetDegree(self.ds, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getPEPDegree(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSPEPSetDegree(__pyx_v_self->ds, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 654, __pyx_L1_error)

  /* "SLEPc/DS.pyx":644
 *         return (toInt(val1), toInt(val2))
 * 
 *     def setPEPDegree(self, deg):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the polynomial degree of a `DS` of type `PEP`.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setPEPDegree", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":656
 *         CHKERR( DSPEPSetDegree(self.ds, val) )
 * 
 *     def getPEPDegree(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the polynomial degree of a `DS` of type `PEP`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_81getPEPDegree(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_80getPEPDegree[] = "DS.getPEPDegree(self)\n\n        Gets the polynomial degree of a `DS` of type `PEP`.\n\n        Returns\n        -------\n        deg: int\n             The polynomial degree.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_81getPEPDegree(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getPEPDegree (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getPEPDegree", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getPEPDegree", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_80getPEPDegree(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_80getPEPDegree(struct PySlepcDSObject *__pyx_v_self) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getPEPDegree", 0);

  /* "SLEPc/DS.pyx":665
 *              The polynomial degree.
 *         """
 *         cdef PetscInt val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( DSPEPGetDegree(self.ds, &val) )
 *         return toInt(val)
 */
  __pyx_v_val = 0;

  /* "SLEPc/DS.pyx":666
 *         """
 *         cdef PetscInt val = 0
 *         CHKERR( DSPEPGetDegree(self.ds, &val) )             # <<<<<<<<<<<<<<
 *         return toInt(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSPEPGetDegree(__pyx_v_self->ds, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 666, __pyx_L1_error)

  /* "SLEPc/DS.pyx":667
 *         cdef PetscInt val = 0
 *         CHKERR( DSPEPGetDegree(self.ds, &val) )
 *         return toInt(val)             # <<<<<<<<<<<<<<
 * 
 *     def setPEPCoefficients(self, pbc):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 667, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":656
 *         CHKERR( DSPEPSetDegree(self.ds, val) )
 * 
 *     def getPEPDegree(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the polynomial degree of a `DS` of type `PEP`.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getPEPDegree", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":669
 *         return toInt(val)
 * 
 *     def setPEPCoefficients(self, pbc):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the polynomial basis coefficients of a `DS` of type `PEP`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_83setPEPCoefficients(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_82setPEPCoefficients[] = "DS.setPEPCoefficients(self, pbc)\n\n        Sets the polynomial basis coefficients of a `DS` of type `PEP`.\n\n        Parameters\n        ----------\n        pbc: array of float\n             Coefficients.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_83setPEPCoefficients(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_pbc = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setPEPCoefficients (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pbc,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pbc)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setPEPCoefficients") < 0)) __PYX_ERR(14, 669, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_pbc = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setPEPCoefficients", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(14, 669, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setPEPCoefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_82setPEPCoefficients(((struct PySlepcDSObject *)__pyx_v_self), __pyx_v_pbc);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_82setPEPCoefficients(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_pbc) {
  PetscInt __pyx_v_na;
  PetscReal *__pyx_v_a;
  CYTHON_UNUSED PyObject *__pyx_v_tmp1 = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setPEPCoefficients", 0);

  /* "SLEPc/DS.pyx":678
 *              Coefficients.
 *         """
 *         cdef PetscInt na = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal *a = NULL
 *         cdef object tmp1 = iarray_r(pbc, &na, &a)
 */
  __pyx_v_na = 0;

  /* "SLEPc/DS.pyx":679
 *         """
 *         cdef PetscInt na = 0
 *         cdef PetscReal *a = NULL             # <<<<<<<<<<<<<<
 *         cdef object tmp1 = iarray_r(pbc, &na, &a)
 *         CHKERR( DSPEPSetCoefficients(self.ds, a) )
 */
  __pyx_v_a = NULL;

  /* "SLEPc/DS.pyx":680
 *         cdef PetscInt na = 0
 *         cdef PetscReal *a = NULL
 *         cdef object tmp1 = iarray_r(pbc, &na, &a)             # <<<<<<<<<<<<<<
 *         CHKERR( DSPEPSetCoefficients(self.ds, a) )
 * 
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_iarray_r(__pyx_v_pbc, (&__pyx_v_na), (&__pyx_v_a))); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 680, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_tmp1 = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/DS.pyx":681
 *         cdef PetscReal *a = NULL
 *         cdef object tmp1 = iarray_r(pbc, &na, &a)
 *         CHKERR( DSPEPSetCoefficients(self.ds, a) )             # <<<<<<<<<<<<<<
 * 
 *     def getPEPCoefficients(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSPEPSetCoefficients(__pyx_v_self->ds, __pyx_v_a)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(14, 681, __pyx_L1_error)

  /* "SLEPc/DS.pyx":669
 *         return toInt(val)
 * 
 *     def setPEPCoefficients(self, pbc):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the polynomial basis coefficients of a `DS` of type `PEP`.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.setPEPCoefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":683
 *         CHKERR( DSPEPSetCoefficients(self.ds, a) )
 * 
 *     def getPEPCoefficients(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the polynomial basis coefficients of a `DS` of type `PEP`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_85getPEPCoefficients(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2DS_84getPEPCoefficients[] = "DS.getPEPCoefficients(self)\n\n        Gets the polynomial basis coefficients of a `DS` of type `PEP`.\n\n        Returns\n        -------\n        pbc: array of float\n             Coefficients.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_85getPEPCoefficients(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getPEPCoefficients (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getPEPCoefficients", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getPEPCoefficients", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_84getPEPCoefficients(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_84getPEPCoefficients(struct PySlepcDSObject *__pyx_v_self) {
  PetscInt __pyx_v_np;
  PetscReal *__pyx_v_coeff;
  PyObject *__pyx_v_ocoeff = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  char const *__pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  PyObject *__pyx_t_10 = NULL;
  int __pyx_t_11;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getPEPCoefficients", 0);

  /* "SLEPc/DS.pyx":692
 *              Coefficients.
 *         """
 *         cdef PetscInt np = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal *coeff = NULL
 *         CHKERR( DSPEPGetDegree(self.ds, &np) )
 */
  __pyx_v_np = 0;

  /* "SLEPc/DS.pyx":693
 *         """
 *         cdef PetscInt np = 0
 *         cdef PetscReal *coeff = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( DSPEPGetDegree(self.ds, &np) )
 *         CHKERR( DSPEPGetCoefficients(self.ds, &coeff) )
 */
  __pyx_v_coeff = NULL;

  /* "SLEPc/DS.pyx":694
 *         cdef PetscInt np = 0
 *         cdef PetscReal *coeff = NULL
 *         CHKERR( DSPEPGetDegree(self.ds, &np) )             # <<<<<<<<<<<<<<
 *         CHKERR( DSPEPGetCoefficients(self.ds, &coeff) )
 *         cdef object ocoeff = None
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSPEPGetDegree(__pyx_v_self->ds, (&__pyx_v_np))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 694, __pyx_L1_error)

  /* "SLEPc/DS.pyx":695
 *         cdef PetscReal *coeff = NULL
 *         CHKERR( DSPEPGetDegree(self.ds, &np) )
 *         CHKERR( DSPEPGetCoefficients(self.ds, &coeff) )             # <<<<<<<<<<<<<<
 *         cdef object ocoeff = None
 *         try:
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(DSPEPGetCoefficients(__pyx_v_self->ds, (&__pyx_v_coeff))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 695, __pyx_L1_error)

  /* "SLEPc/DS.pyx":696
 *         CHKERR( DSPEPGetDegree(self.ds, &np) )
 *         CHKERR( DSPEPGetCoefficients(self.ds, &coeff) )
 *         cdef object ocoeff = None             # <<<<<<<<<<<<<<
 *         try:
 *             ocoeff = array_r(3*(np+1), coeff)
 */
  __Pyx_INCREF(Py_None);
  __pyx_v_ocoeff = Py_None;

  /* "SLEPc/DS.pyx":697
 *         CHKERR( DSPEPGetCoefficients(self.ds, &coeff) )
 *         cdef object ocoeff = None
 *         try:             # <<<<<<<<<<<<<<
 *             ocoeff = array_r(3*(np+1), coeff)
 *         finally:
 */
  /*try:*/ {

    /* "SLEPc/DS.pyx":698
 *         cdef object ocoeff = None
 *         try:
 *             ocoeff = array_r(3*(np+1), coeff)             # <<<<<<<<<<<<<<
 *         finally:
 *             CHKERR( PetscFree(coeff) )
 */
    __pyx_t_2 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_r((3 * (__pyx_v_np + 1)), __pyx_v_coeff)); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 698, __pyx_L4_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_ocoeff, __pyx_t_2);
    __pyx_t_2 = 0;
  }

  /* "SLEPc/DS.pyx":700
 *             ocoeff = array_r(3*(np+1), coeff)
 *         finally:
 *             CHKERR( PetscFree(coeff) )             # <<<<<<<<<<<<<<
 *         return ocoeff
 * 
 */
  /*finally:*/ {
    /*normal exit:*/{
      __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_coeff)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(14, 700, __pyx_L1_error)
      goto __pyx_L5;
    }
    __pyx_L4_error:;
    /*exception exit:*/{
      __Pyx_PyThreadState_declare
      __Pyx_PyThreadState_assign
      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_5);
      __Pyx_XGOTREF(__pyx_t_6);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_8);
      __Pyx_XGOTREF(__pyx_t_9);
      __Pyx_XGOTREF(__pyx_t_10);
      __pyx_t_1 = __pyx_lineno; __pyx_t_3 = __pyx_clineno; __pyx_t_4 = __pyx_filename;
      {
        __pyx_t_11 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_coeff)); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(14, 700, __pyx_L7_error)
      }
      if (PY_MAJOR_VERSION >= 3) {
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
      }
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_XGIVEREF(__pyx_t_7);
      __Pyx_ErrRestore(__pyx_t_5, __pyx_t_6, __pyx_t_7);
      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      __pyx_lineno = __pyx_t_1; __pyx_clineno = __pyx_t_3; __pyx_filename = __pyx_t_4;
      goto __pyx_L1_error;
      __pyx_L7_error:;
      if (PY_MAJOR_VERSION >= 3) {
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
      }
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      goto __pyx_L1_error;
    }
    __pyx_L5:;
  }

  /* "SLEPc/DS.pyx":701
 *         finally:
 *             CHKERR( PetscFree(coeff) )
 *         return ocoeff             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_ocoeff);
  __pyx_r = __pyx_v_ocoeff;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":683
 *         CHKERR( DSPEPSetCoefficients(self.ds, a) )
 * 
 *     def getPEPCoefficients(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the polynomial basis coefficients of a `DS` of type `PEP`.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.getPEPCoefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_ocoeff);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":706
 * 
 *     property state:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getState()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_5state_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_5state_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_5state___get__(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_5state___get__(struct PySlepcDSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/DS.pyx":707
 *     property state:
 *         def __get__(self):
 *             return self.getState()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setState(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getState); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 707, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 707, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":706
 * 
 *     property state:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getState()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.state.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":708
 *         def __get__(self):
 *             return self.getState()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setState(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2DS_5state_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2DS_5state_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_5state_2__set__(((struct PySlepcDSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2DS_5state_2__set__(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/DS.pyx":709
 *             return self.getState()
 *         def __set__(self, value):
 *             self.setState(value)             # <<<<<<<<<<<<<<
 * 
 *     property parallel:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setState); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 709, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 709, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/DS.pyx":708
 *         def __get__(self):
 *             return self.getState()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setState(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.state.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":712
 * 
 *     property parallel:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getParallel()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_8parallel_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_8parallel_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_8parallel___get__(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_8parallel___get__(struct PySlepcDSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/DS.pyx":713
 *     property parallel:
 *         def __get__(self):
 *             return self.getParallel()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setParallel(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getParallel); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 713, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 713, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":712
 * 
 *     property parallel:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getParallel()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.parallel.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":714
 *         def __get__(self):
 *             return self.getParallel()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setParallel(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2DS_8parallel_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2DS_8parallel_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_8parallel_2__set__(((struct PySlepcDSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2DS_8parallel_2__set__(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/DS.pyx":715
 *             return self.getParallel()
 *         def __set__(self, value):
 *             self.setParallel(value)             # <<<<<<<<<<<<<<
 * 
 *     property block_size:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setParallel); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 715, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 715, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/DS.pyx":714
 *         def __get__(self):
 *             return self.getParallel()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setParallel(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.parallel.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":718
 * 
 *     property block_size:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getBlockSize()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_10block_size_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_10block_size_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_10block_size___get__(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_10block_size___get__(struct PySlepcDSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/DS.pyx":719
 *     property block_size:
 *         def __get__(self):
 *             return self.getBlockSize()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setBlockSize(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getBlockSize); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 719, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 719, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":718
 * 
 *     property block_size:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getBlockSize()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.block_size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":720
 *         def __get__(self):
 *             return self.getBlockSize()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setBlockSize(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2DS_10block_size_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2DS_10block_size_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_10block_size_2__set__(((struct PySlepcDSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2DS_10block_size_2__set__(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/DS.pyx":721
 *             return self.getBlockSize()
 *         def __set__(self, value):
 *             self.setBlockSize(value)             # <<<<<<<<<<<<<<
 * 
 *     property method:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setBlockSize); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 721, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 721, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/DS.pyx":720
 *         def __get__(self):
 *             return self.getBlockSize()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setBlockSize(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.block_size.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":724
 * 
 *     property method:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getMethod()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_6method_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_6method_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_6method___get__(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_6method___get__(struct PySlepcDSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/DS.pyx":725
 *     property method:
 *         def __get__(self):
 *             return self.getMethod()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setMethod(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getMethod); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 725, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 725, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":724
 * 
 *     property method:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getMethod()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.method.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":726
 *         def __get__(self):
 *             return self.getMethod()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setMethod(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2DS_6method_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2DS_6method_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_6method_2__set__(((struct PySlepcDSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2DS_6method_2__set__(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/DS.pyx":727
 *             return self.getMethod()
 *         def __set__(self, value):
 *             self.setMethod(value)             # <<<<<<<<<<<<<<
 * 
 *     property compact:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setMethod); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 727, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 727, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/DS.pyx":726
 *         def __get__(self):
 *             return self.getMethod()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setMethod(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.method.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":730
 * 
 *     property compact:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getCompact()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_7compact_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_7compact_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_7compact___get__(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_7compact___get__(struct PySlepcDSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/DS.pyx":731
 *     property compact:
 *         def __get__(self):
 *             return self.getCompact()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setCompact(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getCompact); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 731, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 731, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":730
 * 
 *     property compact:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getCompact()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.compact.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":732
 *         def __get__(self):
 *             return self.getCompact()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setCompact(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2DS_7compact_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2DS_7compact_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_7compact_2__set__(((struct PySlepcDSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2DS_7compact_2__set__(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/DS.pyx":733
 *             return self.getCompact()
 *         def __set__(self, value):
 *             self.setCompact(value)             # <<<<<<<<<<<<<<
 * 
 *     property extra_row:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setCompact); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 733, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 733, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/DS.pyx":732
 *         def __get__(self):
 *             return self.getCompact()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setCompact(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.compact.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":736
 * 
 *     property extra_row:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getExtraRow()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_9extra_row_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_9extra_row_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_9extra_row___get__(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_9extra_row___get__(struct PySlepcDSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/DS.pyx":737
 *     property extra_row:
 *         def __get__(self):
 *             return self.getExtraRow()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setExtraRow(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getExtraRow); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 737, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 737, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":736
 * 
 *     property extra_row:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getExtraRow()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.extra_row.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":738
 *         def __get__(self):
 *             return self.getExtraRow()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setExtraRow(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2DS_9extra_row_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2DS_9extra_row_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_9extra_row_2__set__(((struct PySlepcDSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2DS_9extra_row_2__set__(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/DS.pyx":739
 *             return self.getExtraRow()
 *         def __set__(self, value):
 *             self.setExtraRow(value)             # <<<<<<<<<<<<<<
 * 
 *     property refined:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setExtraRow); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 739, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 739, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/DS.pyx":738
 *         def __get__(self):
 *             return self.getExtraRow()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setExtraRow(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.extra_row.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":742
 * 
 *     property refined:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getRefined()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_7refined_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2DS_7refined_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_7refined___get__(((struct PySlepcDSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2DS_7refined___get__(struct PySlepcDSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/DS.pyx":743
 *     property refined:
 *         def __get__(self):
 *             return self.getRefined()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setRefined(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getRefined); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 743, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/DS.pyx":742
 * 
 *     property refined:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getRefined()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.refined.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/DS.pyx":744
 *         def __get__(self):
 *             return self.getRefined()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setRefined(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2DS_7refined_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2DS_7refined_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2DS_7refined_2__set__(((struct PySlepcDSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2DS_7refined_2__set__(struct PySlepcDSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/DS.pyx":745
 *             return self.getRefined()
 *         def __set__(self, value):
 *             self.setRefined(value)             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setRefined); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 745, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 745, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/DS.pyx":744
 *         def __get__(self):
 *             return self.getRefined()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setRefined(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.DS.refined.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":51
 *     ParallelType = FNParallelType
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.fn
 *         self.fn = NULL
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2FN_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2FN_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN___cinit__(((struct PySlepcFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2FN___cinit__(struct PySlepcFNObject *__pyx_v_self) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "SLEPc/FN.pyx":52
 * 
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.fn             # <<<<<<<<<<<<<<
 *         self.fn = NULL
 * 
 */
  __pyx_v_self->__pyx_base.obj = ((PetscObject *)(&__pyx_v_self->fn));

  /* "SLEPc/FN.pyx":53
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.fn
 *         self.fn = NULL             # <<<<<<<<<<<<<<
 * 
 *     def view(self, Viewer viewer=None):
 */
  __pyx_v_self->fn = NULL;

  /* "SLEPc/FN.pyx":51
 *     ParallelType = FNParallelType
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.fn
 *         self.fn = NULL
 */

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":55
 *         self.fn = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the FN data structure.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_2view[] = "FN.view(self, Viewer viewer=None)\n\n        Prints the FN data structure.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("view (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "view") < 0)) __PYX_ERR(15, 55, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("view", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 55, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(15, 55, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_2view(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_2view(struct PySlepcFNObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("view", 0);

  /* "SLEPc/FN.pyx":65
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( FNView(self.fn, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/FN.pyx":66
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( FNView(self.fn, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def destroy(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNView(__pyx_v_self->fn, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(15, 66, __pyx_L1_error)

  /* "SLEPc/FN.pyx":55
 *         self.fn = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the FN data structure.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":68
 *         CHKERR( FNView(self.fn, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the FN object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_4destroy[] = "FN.destroy(self)\n\n        Destroys the FN object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("destroy (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("destroy", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "destroy", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_4destroy(((struct PySlepcFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_4destroy(struct PySlepcFNObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("destroy", 0);

  /* "SLEPc/FN.pyx":72
 *         Destroys the FN object.
 *         """
 *         CHKERR( FNDestroy(&self.fn) )             # <<<<<<<<<<<<<<
 *         self.fn = NULL
 *         return self
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNDestroy((&__pyx_v_self->fn))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(15, 72, __pyx_L1_error)

  /* "SLEPc/FN.pyx":73
 *         """
 *         CHKERR( FNDestroy(&self.fn) )
 *         self.fn = NULL             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  __pyx_v_self->fn = NULL;

  /* "SLEPc/FN.pyx":74
 *         CHKERR( FNDestroy(&self.fn) )
 *         self.fn = NULL
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def create(self, comm=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":68
 *         CHKERR( FNView(self.fn, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the FN object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.destroy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":76
 *         return self
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the FN object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_7create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_6create[] = "FN.create(self, comm=None)\n\n        Creates the FN object.\n\n        Parameters\n        ----------\n        comm: Comm, optional\n              MPI communicator; if not provided, it defaults to all\n              processes.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_7create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comm = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comm,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comm);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create") < 0)) __PYX_ERR(15, 76, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_comm = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("create", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 76, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_6create(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_comm);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_6create(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_comm) {
  MPI_Comm __pyx_v_ccomm;
  FN __pyx_v_newfn;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  MPI_Comm __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("create", 0);

  /* "SLEPc/FN.pyx":86
 *               processes.
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())             # <<<<<<<<<<<<<<
 *         cdef SlepcFN newfn = NULL
 *         CHKERR( FNCreate(ccomm, &newfn) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_def_Comm(__pyx_v_comm, __pyx_f_8slepc4py_5SLEPc_SLEPC_COMM_DEFAULT()); if (unlikely(PyErr_Occurred())) __PYX_ERR(15, 86, __pyx_L1_error)
  __pyx_v_ccomm = __pyx_t_1;

  /* "SLEPc/FN.pyx":87
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcFN newfn = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( FNCreate(ccomm, &newfn) )
 *         SlepcCLEAR(self.obj); self.fn = newfn
 */
  __pyx_v_newfn = NULL;

  /* "SLEPc/FN.pyx":88
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcFN newfn = NULL
 *         CHKERR( FNCreate(ccomm, &newfn) )             # <<<<<<<<<<<<<<
 *         SlepcCLEAR(self.obj); self.fn = newfn
 *         return self
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNCreate(__pyx_v_ccomm, (&__pyx_v_newfn))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(15, 88, __pyx_L1_error)

  /* "SLEPc/FN.pyx":89
 *         cdef SlepcFN newfn = NULL
 *         CHKERR( FNCreate(ccomm, &newfn) )
 *         SlepcCLEAR(self.obj); self.fn = newfn             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_SlepcCLEAR(__pyx_v_self->__pyx_base.obj));
  __pyx_v_self->fn = __pyx_v_newfn;

  /* "SLEPc/FN.pyx":90
 *         CHKERR( FNCreate(ccomm, &newfn) )
 *         SlepcCLEAR(self.obj); self.fn = newfn
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def setType(self, fn_type):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":76
 *         return self
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the FN object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":92
 *         return self
 * 
 *     def setType(self, fn_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the type for the FN object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_9setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_8setType[] = "FN.setType(self, fn_type)\n\n        Selects the type for the FN object.\n\n        Parameters\n        ----------\n        fn_type: `FN.Type` enumerate\n                  The inner product type to be used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_9setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_fn_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fn_type,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fn_type)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setType") < 0)) __PYX_ERR(15, 92, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_fn_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 92, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_8setType(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_fn_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_8setType(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_fn_type) {
  const char* __pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setType", 0);
  __Pyx_INCREF(__pyx_v_fn_type);

  /* "SLEPc/FN.pyx":101
 *                   The inner product type to be used.
 *         """
 *         cdef SlepcFNType cval = NULL             # <<<<<<<<<<<<<<
 *         fn_type = str2bytes(fn_type, &cval)
 *         CHKERR( FNSetType(self.fn, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/FN.pyx":102
 *         """
 *         cdef SlepcFNType cval = NULL
 *         fn_type = str2bytes(fn_type, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( FNSetType(self.fn, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_fn_type, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 102, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_fn_type, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/FN.pyx":103
 *         cdef SlepcFNType cval = NULL
 *         fn_type = str2bytes(fn_type, &cval)
 *         CHKERR( FNSetType(self.fn, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getType(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNSetType(__pyx_v_self->fn, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(15, 103, __pyx_L1_error)

  /* "SLEPc/FN.pyx":92
 *         return self
 * 
 *     def setType(self, fn_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the type for the FN object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_fn_type);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":105
 *         CHKERR( FNSetType(self.fn, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the FN type of this object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_11getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_10getType[] = "FN.getType(self)\n\n        Gets the FN type of this object.\n\n        Returns\n        -------\n        type: `FN.Type` enumerate\n              The inner product type currently being used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_11getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_10getType(((struct PySlepcFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_10getType(struct PySlepcFNObject *__pyx_v_self) {
  const char* __pyx_v_fn_type;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getType", 0);

  /* "SLEPc/FN.pyx":114
 *               The inner product type currently being used.
 *         """
 *         cdef SlepcFNType fn_type = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( FNGetType(self.fn, &fn_type) )
 *         return bytes2str(fn_type)
 */
  __pyx_v_fn_type = NULL;

  /* "SLEPc/FN.pyx":115
 *         """
 *         cdef SlepcFNType fn_type = NULL
 *         CHKERR( FNGetType(self.fn, &fn_type) )             # <<<<<<<<<<<<<<
 *         return bytes2str(fn_type)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNGetType(__pyx_v_self->fn, (&__pyx_v_fn_type))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(15, 115, __pyx_L1_error)

  /* "SLEPc/FN.pyx":116
 *         cdef SlepcFNType fn_type = NULL
 *         CHKERR( FNGetType(self.fn, &fn_type) )
 *         return bytes2str(fn_type)             # <<<<<<<<<<<<<<
 * 
 *     def setOptionsPrefix(self, prefix):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_fn_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 116, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":105
 *         CHKERR( FNSetType(self.fn, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the FN type of this object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.getType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":118
 *         return bytes2str(fn_type)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all FN options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_13setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_12setOptionsPrefix[] = "FN.setOptionsPrefix(self, prefix)\n\n        Sets the prefix used for searching for all FN options in the\n        database.\n\n        Parameters\n        ----------\n        prefix: string\n                The prefix string to prepend to all FN option\n                requests.\n\n        Notes\n        -----\n        A hyphen (``-``) must NOT be given at the beginning of the\n        prefix name.  The first character of all runtime options is\n        AUTOMATICALLY the hyphen.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_13setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOptionsPrefix") < 0)) __PYX_ERR(15, 118, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 118, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_12setOptionsPrefix(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_12setOptionsPrefix(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/FN.pyx":135
 *         AUTOMATICALLY the hyphen.
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( FNSetOptionsPrefix(self.fn, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/FN.pyx":136
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( FNSetOptionsPrefix(self.fn, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 136, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/FN.pyx":137
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( FNSetOptionsPrefix(self.fn, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getOptionsPrefix(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNSetOptionsPrefix(__pyx_v_self->fn, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(15, 137, __pyx_L1_error)

  /* "SLEPc/FN.pyx":118
 *         return bytes2str(fn_type)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all FN options in the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":139
 *         CHKERR( FNSetOptionsPrefix(self.fn, cval) )
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all FN options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_15getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_14getOptionsPrefix[] = "FN.getOptionsPrefix(self)\n\n        Gets the prefix used for searching for all FN options in the\n        database.\n\n        Returns\n        -------\n        prefix: string\n                The prefix string set for this FN object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_15getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOptionsPrefix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOptionsPrefix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOptionsPrefix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_14getOptionsPrefix(((struct PySlepcFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_14getOptionsPrefix(struct PySlepcFNObject *__pyx_v_self) {
  const char *__pyx_v_prefix;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOptionsPrefix", 0);

  /* "SLEPc/FN.pyx":149
 *                 The prefix string set for this FN object.
 *         """
 *         cdef const_char *prefix = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( FNGetOptionsPrefix(self.fn, &prefix) )
 *         return bytes2str(prefix)
 */
  __pyx_v_prefix = NULL;

  /* "SLEPc/FN.pyx":150
 *         """
 *         cdef const_char *prefix = NULL
 *         CHKERR( FNGetOptionsPrefix(self.fn, &prefix) )             # <<<<<<<<<<<<<<
 *         return bytes2str(prefix)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNGetOptionsPrefix(__pyx_v_self->fn, (&__pyx_v_prefix))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(15, 150, __pyx_L1_error)

  /* "SLEPc/FN.pyx":151
 *         cdef const_char *prefix = NULL
 *         CHKERR( FNGetOptionsPrefix(self.fn, &prefix) )
 *         return bytes2str(prefix)             # <<<<<<<<<<<<<<
 * 
 *     def setFromOptions(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_prefix); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 151, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":139
 *         CHKERR( FNSetOptionsPrefix(self.fn, cval) )
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all FN options in the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.getOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":153
 *         return bytes2str(prefix)
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets FN options from the options database.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_17setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_16setFromOptions[] = "FN.setFromOptions(self)\n\n        Sets FN options from the options database.\n\n        Notes\n        -----\n        To see all options, run your program with the ``-help``\n        option.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_17setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFromOptions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setFromOptions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setFromOptions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_16setFromOptions(((struct PySlepcFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_16setFromOptions(struct PySlepcFNObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFromOptions", 0);

  /* "SLEPc/FN.pyx":162
 *         option.
 *         """
 *         CHKERR( FNSetFromOptions(self.fn) )             # <<<<<<<<<<<<<<
 * 
 *     def duplicate(self, comm=None):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNSetFromOptions(__pyx_v_self->fn)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(15, 162, __pyx_L1_error)

  /* "SLEPc/FN.pyx":153
 *         return bytes2str(prefix)
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets FN options from the options database.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setFromOptions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":164
 *         CHKERR( FNSetFromOptions(self.fn) )
 * 
 *     def duplicate(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Duplicate the FN object copying all parameters, possibly with a
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_19duplicate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_18duplicate[] = "FN.duplicate(self, comm=None)\n\n        Duplicate the FN object copying all parameters, possibly with a\n        different communicator.\n\n        Parameters\n        ----------\n        comm: Comm, optional\n              MPI communicator; if not provided, it defaults to the\n              object's communicator.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_19duplicate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comm = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("duplicate (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comm,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comm);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "duplicate") < 0)) __PYX_ERR(15, 164, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_comm = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("duplicate", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 164, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.duplicate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_18duplicate(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_comm);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_18duplicate(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_comm) {
  MPI_Comm __pyx_v_ccomm;
  struct PySlepcFNObject *__pyx_v_fn = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  MPI_Comm __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("duplicate", 0);

  /* "SLEPc/FN.pyx":175
 *               object's communicator.
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, PetscObjectComm(<PetscObject>self.fn))             # <<<<<<<<<<<<<<
 *         cdef FN fn = type(self)()
 *         CHKERR( FNDuplicate(self.fn, ccomm, &fn.fn) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_def_Comm(__pyx_v_comm, PetscObjectComm(((PetscObject)__pyx_v_self->fn))); if (unlikely(PyErr_Occurred())) __PYX_ERR(15, 175, __pyx_L1_error)
  __pyx_v_ccomm = __pyx_t_1;

  /* "SLEPc/FN.pyx":176
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, PetscObjectComm(<PetscObject>self.fn))
 *         cdef FN fn = type(self)()             # <<<<<<<<<<<<<<
 *         CHKERR( FNDuplicate(self.fn, ccomm, &fn.fn) )
 *         return fn
 */
  __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
  __pyx_t_3 = ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))); __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 176, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_8slepc4py_5SLEPc_FN))))) __PYX_ERR(15, 176, __pyx_L1_error)
  __pyx_v_fn = ((struct PySlepcFNObject *)__pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/FN.pyx":177
 *         cdef MPI_Comm ccomm = def_Comm(comm, PetscObjectComm(<PetscObject>self.fn))
 *         cdef FN fn = type(self)()
 *         CHKERR( FNDuplicate(self.fn, ccomm, &fn.fn) )             # <<<<<<<<<<<<<<
 *         return fn
 * 
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNDuplicate(__pyx_v_self->fn, __pyx_v_ccomm, (&__pyx_v_fn->fn))); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(15, 177, __pyx_L1_error)

  /* "SLEPc/FN.pyx":178
 *         cdef FN fn = type(self)()
 *         CHKERR( FNDuplicate(self.fn, ccomm, &fn.fn) )
 *         return fn             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_fn));
  __pyx_r = ((PyObject *)__pyx_v_fn);
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":164
 *         CHKERR( FNSetFromOptions(self.fn) )
 * 
 *     def duplicate(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Duplicate the FN object copying all parameters, possibly with a
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.duplicate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_fn);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":182
 *     #
 * 
 *     def evaluateFunction(self, x):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the value of the function f(x) for a given x.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_21evaluateFunction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_20evaluateFunction[] = "FN.evaluateFunction(self, x)\n\n        Computes the value of the function f(x) for a given x.\n\n        Parameters\n        ----------\n        x: scalar\n            Value where the function must be evaluated.\n\n        Returns\n        -------\n        y: scalar\n            The result of f(x).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_21evaluateFunction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_x = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("evaluateFunction (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "evaluateFunction") < 0)) __PYX_ERR(15, 182, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_x = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("evaluateFunction", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 182, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.evaluateFunction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_20evaluateFunction(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_x);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_20evaluateFunction(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_x) {
  PetscScalar __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("evaluateFunction", 0);

  /* "SLEPc/FN.pyx":196
 *             The result of f(x).
 *         """
 *         cdef PetscScalar sval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( FNEvaluateFunction(self.fn, x, &sval) )
 *         return toScalar(sval)
 */
  __pyx_v_sval = 0.0;

  /* "SLEPc/FN.pyx":197
 *         """
 *         cdef PetscScalar sval = 0
 *         CHKERR( FNEvaluateFunction(self.fn, x, &sval) )             # <<<<<<<<<<<<<<
 *         return toScalar(sval)
 * 
 */
  __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_x); if (unlikely((__pyx_t_1 == ((PetscScalar)-1)) && PyErr_Occurred())) __PYX_ERR(15, 197, __pyx_L1_error)
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNEvaluateFunction(__pyx_v_self->fn, __pyx_t_1, (&__pyx_v_sval))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(15, 197, __pyx_L1_error)

  /* "SLEPc/FN.pyx":198
 *         cdef PetscScalar sval = 0
 *         CHKERR( FNEvaluateFunction(self.fn, x, &sval) )
 *         return toScalar(sval)             # <<<<<<<<<<<<<<
 * 
 *     def evaluateDerivative(self, x):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_sval); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 198, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":182
 *     #
 * 
 *     def evaluateFunction(self, x):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the value of the function f(x) for a given x.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.evaluateFunction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":200
 *         return toScalar(sval)
 * 
 *     def evaluateDerivative(self, x):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the value of the derivative f'(x) for a given x.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_23evaluateDerivative(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_22evaluateDerivative[] = "FN.evaluateDerivative(self, x)\n\n        Computes the value of the derivative f'(x) for a given x.\n\n        Parameters\n        ----------\n        x: scalar\n            Value where the derivative must be evaluated.\n\n        Returns\n        -------\n        y: scalar\n            The result of f'(x).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_23evaluateDerivative(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_x = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("evaluateDerivative (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "evaluateDerivative") < 0)) __PYX_ERR(15, 200, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_x = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("evaluateDerivative", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 200, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.evaluateDerivative", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_22evaluateDerivative(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_x);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_22evaluateDerivative(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_x) {
  PetscScalar __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("evaluateDerivative", 0);

  /* "SLEPc/FN.pyx":214
 *             The result of f'(x).
 *         """
 *         cdef PetscScalar sval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( FNEvaluateDerivative(self.fn, x, &sval) )
 *         return toScalar(sval)
 */
  __pyx_v_sval = 0.0;

  /* "SLEPc/FN.pyx":215
 *         """
 *         cdef PetscScalar sval = 0
 *         CHKERR( FNEvaluateDerivative(self.fn, x, &sval) )             # <<<<<<<<<<<<<<
 *         return toScalar(sval)
 * 
 */
  __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_x); if (unlikely((__pyx_t_1 == ((PetscScalar)-1)) && PyErr_Occurred())) __PYX_ERR(15, 215, __pyx_L1_error)
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNEvaluateDerivative(__pyx_v_self->fn, __pyx_t_1, (&__pyx_v_sval))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(15, 215, __pyx_L1_error)

  /* "SLEPc/FN.pyx":216
 *         cdef PetscScalar sval = 0
 *         CHKERR( FNEvaluateDerivative(self.fn, x, &sval) )
 *         return toScalar(sval)             # <<<<<<<<<<<<<<
 * 
 *     def evaluateFunctionMat(self, Mat A, Mat B=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_sval); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":200
 *         return toScalar(sval)
 * 
 *     def evaluateDerivative(self, x):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the value of the derivative f'(x) for a given x.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.evaluateDerivative", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":218
 *         return toScalar(sval)
 * 
 *     def evaluateFunctionMat(self, Mat A, Mat B=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the value of the function f(A) for a given matrix A.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_25evaluateFunctionMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_24evaluateFunctionMat[] = "FN.evaluateFunctionMat(self, Mat A, Mat B=None)\n\n        Computes the value of the function f(A) for a given matrix A.\n\n        Parameters\n        ----------\n        A: Mat\n           Matrix on which the function must be evaluated.\n        B: Mat, optional\n           Placeholder for the result.\n\n        Returns\n        -------\n        B: Mat\n           The result of f(A).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_25evaluateFunctionMat(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  struct PyPetscMatObject *__pyx_v_B = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("evaluateFunctionMat (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_A,&__pyx_n_s_B,0};
    PyObject* values[2] = {0,0};
    values[1] = (PyObject *)((struct PyPetscMatObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_A)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_B);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "evaluateFunctionMat") < 0)) __PYX_ERR(15, 218, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_A = ((struct PyPetscMatObject *)values[0]);
    __pyx_v_B = ((struct PyPetscMatObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("evaluateFunctionMat", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 218, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.evaluateFunctionMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_A), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "A", 0))) __PYX_ERR(15, 218, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_B), __pyx_ptype_8petsc4py_5PETSc_Mat, 1, "B", 0))) __PYX_ERR(15, 218, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_24evaluateFunctionMat(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_A, __pyx_v_B);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_24evaluateFunctionMat(struct PySlepcFNObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, struct PyPetscMatObject *__pyx_v_B) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("evaluateFunctionMat", 0);
  __Pyx_INCREF((PyObject *)__pyx_v_B);

  /* "SLEPc/FN.pyx":234
 *            The result of f(A).
 *         """
 *         if B is None: B = A.duplicate()             # <<<<<<<<<<<<<<
 *         CHKERR( FNEvaluateFunctionMat(self.fn, A.mat, B.mat) )
 *         return B
 */
  __pyx_t_1 = (((PyObject *)__pyx_v_B) == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_A), __pyx_n_s_duplicate); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 234, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = NULL;
    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
      if (likely(__pyx_t_5)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_4, function);
      }
    }
    __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 234, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8petsc4py_5PETSc_Mat))))) __PYX_ERR(15, 234, __pyx_L1_error)
    __Pyx_DECREF_SET(__pyx_v_B, ((struct PyPetscMatObject *)__pyx_t_3));
    __pyx_t_3 = 0;
  }

  /* "SLEPc/FN.pyx":235
 *         """
 *         if B is None: B = A.duplicate()
 *         CHKERR( FNEvaluateFunctionMat(self.fn, A.mat, B.mat) )             # <<<<<<<<<<<<<<
 *         return B
 * 
 */
  __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNEvaluateFunctionMat(__pyx_v_self->fn, __pyx_v_A->mat, __pyx_v_B->mat)); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(15, 235, __pyx_L1_error)

  /* "SLEPc/FN.pyx":236
 *         if B is None: B = A.duplicate()
 *         CHKERR( FNEvaluateFunctionMat(self.fn, A.mat, B.mat) )
 *         return B             # <<<<<<<<<<<<<<
 * 
 *     def evaluateFunctionMatVec(self, Mat A, Vec v=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_B));
  __pyx_r = ((PyObject *)__pyx_v_B);
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":218
 *         return toScalar(sval)
 * 
 *     def evaluateFunctionMat(self, Mat A, Mat B=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the value of the function f(A) for a given matrix A.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.evaluateFunctionMat", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_B);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":238
 *         return B
 * 
 *     def evaluateFunctionMatVec(self, Mat A, Vec v=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the first column of the matrix f(A) for a given matrix A.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_27evaluateFunctionMatVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_26evaluateFunctionMatVec[] = "FN.evaluateFunctionMatVec(self, Mat A, Vec v=None)\n\n        Computes the first column of the matrix f(A) for a given matrix A.\n\n        Parameters\n        ----------\n        A: Mat\n           Matrix on which the function must be evaluated.\n\n        Returns\n        -------\n        v: Vec\n           The first column of the result f(A).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_27evaluateFunctionMatVec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  struct PyPetscVecObject *__pyx_v_v = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("evaluateFunctionMatVec (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_A,&__pyx_n_s_v,0};
    PyObject* values[2] = {0,0};
    values[1] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_A)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_v);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "evaluateFunctionMatVec") < 0)) __PYX_ERR(15, 238, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_A = ((struct PyPetscMatObject *)values[0]);
    __pyx_v_v = ((struct PyPetscVecObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("evaluateFunctionMatVec", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 238, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.evaluateFunctionMatVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_A), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "A", 0))) __PYX_ERR(15, 238, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "v", 0))) __PYX_ERR(15, 238, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_26evaluateFunctionMatVec(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_A, __pyx_v_v);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_26evaluateFunctionMatVec(struct PySlepcFNObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, struct PyPetscVecObject *__pyx_v_v) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("evaluateFunctionMatVec", 0);
  __Pyx_INCREF((PyObject *)__pyx_v_v);

  /* "SLEPc/FN.pyx":252
 *            The first column of the result f(A).
 *         """
 *         if v is None: v = A.createVecs('left')             # <<<<<<<<<<<<<<
 *         CHKERR( FNEvaluateFunctionMatVec(self.fn, A.mat, v.vec) )
 *         return v
 */
  __pyx_t_1 = (((PyObject *)__pyx_v_v) == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_A), __pyx_n_s_createVecs); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 252, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = NULL;
    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
      if (likely(__pyx_t_5)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_4, function);
      }
    }
    __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_n_s_left) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_n_s_left);
    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 252, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8petsc4py_5PETSc_Vec))))) __PYX_ERR(15, 252, __pyx_L1_error)
    __Pyx_DECREF_SET(__pyx_v_v, ((struct PyPetscVecObject *)__pyx_t_3));
    __pyx_t_3 = 0;
  }

  /* "SLEPc/FN.pyx":253
 *         """
 *         if v is None: v = A.createVecs('left')
 *         CHKERR( FNEvaluateFunctionMatVec(self.fn, A.mat, v.vec) )             # <<<<<<<<<<<<<<
 *         return v
 * 
 */
  __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNEvaluateFunctionMatVec(__pyx_v_self->fn, __pyx_v_A->mat, __pyx_v_v->vec)); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(15, 253, __pyx_L1_error)

  /* "SLEPc/FN.pyx":254
 *         if v is None: v = A.createVecs('left')
 *         CHKERR( FNEvaluateFunctionMatVec(self.fn, A.mat, v.vec) )
 *         return v             # <<<<<<<<<<<<<<
 * 
 *     def setScale(self, alpha=None, beta=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_v));
  __pyx_r = ((PyObject *)__pyx_v_v);
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":238
 *         return B
 * 
 *     def evaluateFunctionMatVec(self, Mat A, Vec v=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the first column of the matrix f(A) for a given matrix A.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.evaluateFunctionMatVec", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_v);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":256
 *         return v
 * 
 *     def setScale(self, alpha=None, beta=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the scaling parameters that define the matematical function.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_29setScale(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_28setScale[] = "FN.setScale(self, alpha=None, beta=None)\n\n        Sets the scaling parameters that define the matematical function.\n\n        Parameters\n        ----------\n        alpha: scalar (possibly complex), optional\n               Inner scaling (argument), default is 1.0.\n        beta: scalar (possibly complex), optional\n               Outer scaling (result), default is 1.0.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_29setScale(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_alpha = 0;
  PyObject *__pyx_v_beta = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setScale (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alpha,&__pyx_n_s_beta,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_beta);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setScale") < 0)) __PYX_ERR(15, 256, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_alpha = values[0];
    __pyx_v_beta = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setScale", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 256, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setScale", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_28setScale(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_alpha, __pyx_v_beta);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_28setScale(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_alpha, PyObject *__pyx_v_beta) {
  PetscScalar __pyx_v_aval;
  PetscScalar __pyx_v_bval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscScalar __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setScale", 0);

  /* "SLEPc/FN.pyx":267
 *                Outer scaling (result), default is 1.0.
 *         """
 *         cdef PetscScalar aval = 1.0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar bval = 1.0
 *         if alpha is not None: aval = asScalar(alpha)
 */
  __pyx_v_aval = 1.0;

  /* "SLEPc/FN.pyx":268
 *         """
 *         cdef PetscScalar aval = 1.0
 *         cdef PetscScalar bval = 1.0             # <<<<<<<<<<<<<<
 *         if alpha is not None: aval = asScalar(alpha)
 *         if beta  is not None: bval = asScalar(beta)
 */
  __pyx_v_bval = 1.0;

  /* "SLEPc/FN.pyx":269
 *         cdef PetscScalar aval = 1.0
 *         cdef PetscScalar bval = 1.0
 *         if alpha is not None: aval = asScalar(alpha)             # <<<<<<<<<<<<<<
 *         if beta  is not None: bval = asScalar(beta)
 *         CHKERR( FNSetScale(self.fn, aval, bval) )
 */
  __pyx_t_1 = (__pyx_v_alpha != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_alpha); if (unlikely(__pyx_t_3 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(15, 269, __pyx_L1_error)
    __pyx_v_aval = __pyx_t_3;
  }

  /* "SLEPc/FN.pyx":270
 *         cdef PetscScalar bval = 1.0
 *         if alpha is not None: aval = asScalar(alpha)
 *         if beta  is not None: bval = asScalar(beta)             # <<<<<<<<<<<<<<
 *         CHKERR( FNSetScale(self.fn, aval, bval) )
 * 
 */
  __pyx_t_2 = (__pyx_v_beta != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_beta); if (unlikely(__pyx_t_3 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(15, 270, __pyx_L1_error)
    __pyx_v_bval = __pyx_t_3;
  }

  /* "SLEPc/FN.pyx":271
 *         if alpha is not None: aval = asScalar(alpha)
 *         if beta  is not None: bval = asScalar(beta)
 *         CHKERR( FNSetScale(self.fn, aval, bval) )             # <<<<<<<<<<<<<<
 * 
 *     def getScale(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNSetScale(__pyx_v_self->fn, __pyx_v_aval, __pyx_v_bval)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(15, 271, __pyx_L1_error)

  /* "SLEPc/FN.pyx":256
 *         return v
 * 
 *     def setScale(self, alpha=None, beta=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the scaling parameters that define the matematical function.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setScale", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":273
 *         CHKERR( FNSetScale(self.fn, aval, bval) )
 * 
 *     def getScale(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the scaling parameters that define the matematical function.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_31getScale(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_30getScale[] = "FN.getScale(self)\n\n        Gets the scaling parameters that define the matematical function.\n\n        Returns\n        -------\n        alpha: scalar (possibly complex)\n               Inner scaling (argument).\n        beta: scalar (possibly complex)\n               Outer scaling (result).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_31getScale(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getScale (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getScale", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getScale", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_30getScale(((struct PySlepcFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_30getScale(struct PySlepcFNObject *__pyx_v_self) {
  PetscScalar __pyx_v_aval;
  PetscScalar __pyx_v_bval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getScale", 0);

  /* "SLEPc/FN.pyx":284
 *                Outer scaling (result).
 *         """
 *         cdef PetscScalar aval = 0, bval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( FNGetScale(self.fn, &aval, &bval) )
 *         return (toScalar(aval), toScalar(bval))
 */
  __pyx_v_aval = 0.0;
  __pyx_v_bval = 0.0;

  /* "SLEPc/FN.pyx":285
 *         """
 *         cdef PetscScalar aval = 0, bval = 0
 *         CHKERR( FNGetScale(self.fn, &aval, &bval) )             # <<<<<<<<<<<<<<
 *         return (toScalar(aval), toScalar(bval))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNGetScale(__pyx_v_self->fn, (&__pyx_v_aval), (&__pyx_v_bval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(15, 285, __pyx_L1_error)

  /* "SLEPc/FN.pyx":286
 *         cdef PetscScalar aval = 0, bval = 0
 *         CHKERR( FNGetScale(self.fn, &aval, &bval) )
 *         return (toScalar(aval), toScalar(bval))             # <<<<<<<<<<<<<<
 * 
 *     def setMethod(self, meth):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_aval); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 286, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_bval); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 286, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 286, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":273
 *         CHKERR( FNSetScale(self.fn, aval, bval) )
 * 
 *     def getScale(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the scaling parameters that define the matematical function.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.getScale", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":288
 *         return (toScalar(aval), toScalar(bval))
 * 
 *     def setMethod(self, meth):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the method to be used to evaluate functions of matrices.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_33setMethod(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_32setMethod[] = "FN.setMethod(self, meth)\n\n        Selects the method to be used to evaluate functions of matrices.\n\n        Parameters\n        ----------\n        meth: int\n              An index identifying the method.\n\n        Notes\n        -----\n        In some `FN` types there are more than one algorithms available\n        for computing matrix functions. In that case, this function allows\n        choosing the wanted method.\n\n        If `meth` is currently set to 0 and the input argument of\n        `FN.evaluateFunctionMat()` is a symmetric/Hermitian matrix, then\n        the computation is done via the eigendecomposition, rather than\n        with the general algorithm.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_33setMethod(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_meth = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setMethod (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_meth,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_meth)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setMethod") < 0)) __PYX_ERR(15, 288, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_meth = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setMethod", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 288, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setMethod", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_32setMethod(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_meth);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_32setMethod(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_meth) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setMethod", 0);

  /* "SLEPc/FN.pyx":308
 *         with the general algorithm.
 *         """
 *         cdef PetscInt val = asInt(meth)             # <<<<<<<<<<<<<<
 *         CHKERR( FNSetMethod(self.fn, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_meth); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(15, 308, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/FN.pyx":309
 *         """
 *         cdef PetscInt val = asInt(meth)
 *         CHKERR( FNSetMethod(self.fn, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getMethod(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNSetMethod(__pyx_v_self->fn, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(15, 309, __pyx_L1_error)

  /* "SLEPc/FN.pyx":288
 *         return (toScalar(aval), toScalar(bval))
 * 
 *     def setMethod(self, meth):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the method to be used to evaluate functions of matrices.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setMethod", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":311
 *         CHKERR( FNSetMethod(self.fn, val) )
 * 
 *     def getMethod(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the method currently used for matrix functions.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_35getMethod(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_34getMethod[] = "FN.getMethod(self)\n\n        Gets the method currently used for matrix functions.\n\n        Returns\n        -------\n        meth: int\n              An index identifying the method.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_35getMethod(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getMethod (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getMethod", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getMethod", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_34getMethod(((struct PySlepcFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_34getMethod(struct PySlepcFNObject *__pyx_v_self) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getMethod", 0);

  /* "SLEPc/FN.pyx":320
 *               An index identifying the method.
 *         """
 *         cdef PetscInt val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( FNGetMethod(self.fn, &val) )
 *         return toInt(val)
 */
  __pyx_v_val = 0;

  /* "SLEPc/FN.pyx":321
 *         """
 *         cdef PetscInt val = 0
 *         CHKERR( FNGetMethod(self.fn, &val) )             # <<<<<<<<<<<<<<
 *         return toInt(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNGetMethod(__pyx_v_self->fn, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(15, 321, __pyx_L1_error)

  /* "SLEPc/FN.pyx":322
 *         cdef PetscInt val = 0
 *         CHKERR( FNGetMethod(self.fn, &val) )
 *         return toInt(val)             # <<<<<<<<<<<<<<
 * 
 *     def setParallel(self, pmode):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 322, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":311
 *         CHKERR( FNSetMethod(self.fn, val) )
 * 
 *     def getMethod(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the method currently used for matrix functions.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.getMethod", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":324
 *         return toInt(val)
 * 
 *     def setParallel(self, pmode):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the mode of operation in parallel runs.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_37setParallel(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_36setParallel[] = "FN.setParallel(self, pmode)\n\n        Selects the mode of operation in parallel runs.\n\n        Parameters\n        ----------\n        pmode: `FN.ParallelType` enumerate\n               The parallel mode.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_37setParallel(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_pmode = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setParallel (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pmode,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pmode)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setParallel") < 0)) __PYX_ERR(15, 324, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_pmode = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setParallel", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 324, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setParallel", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_36setParallel(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_pmode);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_36setParallel(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_pmode) {
  FNParallelType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  FNParallelType __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setParallel", 0);

  /* "SLEPc/FN.pyx":333
 *                The parallel mode.
 *         """
 *         cdef SlepcFNParallelType val = pmode             # <<<<<<<<<<<<<<
 *         CHKERR( FNSetParallel(self.fn, val) )
 * 
 */
  __pyx_t_1 = ((FNParallelType)__Pyx_PyInt_As_FNParallelType(__pyx_v_pmode)); if (unlikely(PyErr_Occurred())) __PYX_ERR(15, 333, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/FN.pyx":334
 *         """
 *         cdef SlepcFNParallelType val = pmode
 *         CHKERR( FNSetParallel(self.fn, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getParallel(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNSetParallel(__pyx_v_self->fn, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(15, 334, __pyx_L1_error)

  /* "SLEPc/FN.pyx":324
 *         return toInt(val)
 * 
 *     def setParallel(self, pmode):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the mode of operation in parallel runs.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setParallel", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":336
 *         CHKERR( FNSetParallel(self.fn, val) )
 * 
 *     def getParallel(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the mode of operation in parallel runs.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_39getParallel(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_38getParallel[] = "FN.getParallel(self)\n\n        Gets the mode of operation in parallel runs.\n\n        Returns\n        -------\n        pmode: `FN.ParallelType` enumerate\n               The parallel mode.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_39getParallel(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getParallel (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getParallel", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getParallel", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_38getParallel(((struct PySlepcFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_38getParallel(struct PySlepcFNObject *__pyx_v_self) {
  FNParallelType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getParallel", 0);

  /* "SLEPc/FN.pyx":345
 *                The parallel mode.
 *         """
 *         cdef SlepcFNParallelType val = FN_PARALLEL_REDUNDANT             # <<<<<<<<<<<<<<
 *         CHKERR( FNGetParallel(self.fn, &val) )
 *         return val
 */
  __pyx_v_val = FN_PARALLEL_REDUNDANT;

  /* "SLEPc/FN.pyx":346
 *         """
 *         cdef SlepcFNParallelType val = FN_PARALLEL_REDUNDANT
 *         CHKERR( FNGetParallel(self.fn, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNGetParallel(__pyx_v_self->fn, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(15, 346, __pyx_L1_error)

  /* "SLEPc/FN.pyx":347
 *         cdef SlepcFNParallelType val = FN_PARALLEL_REDUNDANT
 *         CHKERR( FNGetParallel(self.fn, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_FNParallelType(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 347, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":336
 *         CHKERR( FNSetParallel(self.fn, val) )
 * 
 *     def getParallel(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the mode of operation in parallel runs.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.getParallel", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":351
 *     #
 * 
 *     def setRationalNumerator(self, alpha):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the coefficients of the numerator of the rational function.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_41setRationalNumerator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_40setRationalNumerator[] = "FN.setRationalNumerator(self, alpha)\n\n        Sets the coefficients of the numerator of the rational function.\n\n        Parameters\n        ----------\n        alpha: array of scalars\n            Coefficients.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_41setRationalNumerator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_alpha = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRationalNumerator (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alpha,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRationalNumerator") < 0)) __PYX_ERR(15, 351, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_alpha = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRationalNumerator", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 351, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setRationalNumerator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_40setRationalNumerator(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_alpha);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_40setRationalNumerator(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_alpha) {
  PetscInt __pyx_v_na;
  PetscScalar *__pyx_v_a;
  CYTHON_UNUSED PyObject *__pyx_v_tmp1 = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRationalNumerator", 0);

  /* "SLEPc/FN.pyx":360
 *             Coefficients.
 *         """
 *         cdef PetscInt na = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar *a = NULL
 *         cdef object tmp1 = iarray_s(alpha, &na, &a)
 */
  __pyx_v_na = 0;

  /* "SLEPc/FN.pyx":361
 *         """
 *         cdef PetscInt na = 0
 *         cdef PetscScalar *a = NULL             # <<<<<<<<<<<<<<
 *         cdef object tmp1 = iarray_s(alpha, &na, &a)
 *         CHKERR( FNRationalSetNumerator(self.fn, na, a) )
 */
  __pyx_v_a = NULL;

  /* "SLEPc/FN.pyx":362
 *         cdef PetscInt na = 0
 *         cdef PetscScalar *a = NULL
 *         cdef object tmp1 = iarray_s(alpha, &na, &a)             # <<<<<<<<<<<<<<
 *         CHKERR( FNRationalSetNumerator(self.fn, na, a) )
 * 
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_iarray_s(__pyx_v_alpha, (&__pyx_v_na), (&__pyx_v_a))); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 362, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_tmp1 = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/FN.pyx":363
 *         cdef PetscScalar *a = NULL
 *         cdef object tmp1 = iarray_s(alpha, &na, &a)
 *         CHKERR( FNRationalSetNumerator(self.fn, na, a) )             # <<<<<<<<<<<<<<
 * 
 *     def getRationalNumerator(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNRationalSetNumerator(__pyx_v_self->fn, __pyx_v_na, __pyx_v_a)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(15, 363, __pyx_L1_error)

  /* "SLEPc/FN.pyx":351
 *     #
 * 
 *     def setRationalNumerator(self, alpha):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the coefficients of the numerator of the rational function.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setRationalNumerator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":365
 *         CHKERR( FNRationalSetNumerator(self.fn, na, a) )
 * 
 *     def getRationalNumerator(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the coefficients of the numerator of the rational function.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_43getRationalNumerator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_42getRationalNumerator[] = "FN.getRationalNumerator(self)\n\n        Gets the coefficients of the numerator of the rational function.\n\n        Returns\n        -------\n        alpha: array of scalars\n            Coefficients.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_43getRationalNumerator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRationalNumerator (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRationalNumerator", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRationalNumerator", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_42getRationalNumerator(((struct PySlepcFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_42getRationalNumerator(struct PySlepcFNObject *__pyx_v_self) {
  PetscInt __pyx_v_np;
  PetscScalar *__pyx_v_coeff;
  PyObject *__pyx_v_ocoeff = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  char const *__pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  PyObject *__pyx_t_10 = NULL;
  int __pyx_t_11;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRationalNumerator", 0);

  /* "SLEPc/FN.pyx":374
 *             Coefficients.
 *         """
 *         cdef PetscInt np = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar *coeff = NULL
 *         CHKERR( FNRationalGetNumerator(self.fn, &np, &coeff) )
 */
  __pyx_v_np = 0;

  /* "SLEPc/FN.pyx":375
 *         """
 *         cdef PetscInt np = 0
 *         cdef PetscScalar *coeff = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( FNRationalGetNumerator(self.fn, &np, &coeff) )
 *         cdef object ocoeff = None
 */
  __pyx_v_coeff = NULL;

  /* "SLEPc/FN.pyx":376
 *         cdef PetscInt np = 0
 *         cdef PetscScalar *coeff = NULL
 *         CHKERR( FNRationalGetNumerator(self.fn, &np, &coeff) )             # <<<<<<<<<<<<<<
 *         cdef object ocoeff = None
 *         try:
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNRationalGetNumerator(__pyx_v_self->fn, (&__pyx_v_np), (&__pyx_v_coeff))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(15, 376, __pyx_L1_error)

  /* "SLEPc/FN.pyx":377
 *         cdef PetscScalar *coeff = NULL
 *         CHKERR( FNRationalGetNumerator(self.fn, &np, &coeff) )
 *         cdef object ocoeff = None             # <<<<<<<<<<<<<<
 *         try:
 *             ocoeff = array_s(np, coeff)
 */
  __Pyx_INCREF(Py_None);
  __pyx_v_ocoeff = Py_None;

  /* "SLEPc/FN.pyx":378
 *         CHKERR( FNRationalGetNumerator(self.fn, &np, &coeff) )
 *         cdef object ocoeff = None
 *         try:             # <<<<<<<<<<<<<<
 *             ocoeff = array_s(np, coeff)
 *         finally:
 */
  /*try:*/ {

    /* "SLEPc/FN.pyx":379
 *         cdef object ocoeff = None
 *         try:
 *             ocoeff = array_s(np, coeff)             # <<<<<<<<<<<<<<
 *         finally:
 *             CHKERR( PetscFree(coeff) )
 */
    __pyx_t_2 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_s(__pyx_v_np, __pyx_v_coeff)); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 379, __pyx_L4_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_ocoeff, __pyx_t_2);
    __pyx_t_2 = 0;
  }

  /* "SLEPc/FN.pyx":381
 *             ocoeff = array_s(np, coeff)
 *         finally:
 *             CHKERR( PetscFree(coeff) )             # <<<<<<<<<<<<<<
 *         return ocoeff
 * 
 */
  /*finally:*/ {
    /*normal exit:*/{
      __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_coeff)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(15, 381, __pyx_L1_error)
      goto __pyx_L5;
    }
    __pyx_L4_error:;
    /*exception exit:*/{
      __Pyx_PyThreadState_declare
      __Pyx_PyThreadState_assign
      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_5);
      __Pyx_XGOTREF(__pyx_t_6);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_8);
      __Pyx_XGOTREF(__pyx_t_9);
      __Pyx_XGOTREF(__pyx_t_10);
      __pyx_t_1 = __pyx_lineno; __pyx_t_3 = __pyx_clineno; __pyx_t_4 = __pyx_filename;
      {
        __pyx_t_11 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_coeff)); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(15, 381, __pyx_L7_error)
      }
      if (PY_MAJOR_VERSION >= 3) {
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
      }
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_XGIVEREF(__pyx_t_7);
      __Pyx_ErrRestore(__pyx_t_5, __pyx_t_6, __pyx_t_7);
      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      __pyx_lineno = __pyx_t_1; __pyx_clineno = __pyx_t_3; __pyx_filename = __pyx_t_4;
      goto __pyx_L1_error;
      __pyx_L7_error:;
      if (PY_MAJOR_VERSION >= 3) {
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
      }
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      goto __pyx_L1_error;
    }
    __pyx_L5:;
  }

  /* "SLEPc/FN.pyx":382
 *         finally:
 *             CHKERR( PetscFree(coeff) )
 *         return ocoeff             # <<<<<<<<<<<<<<
 * 
 *     def setRationalDenominator(self, alpha):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_ocoeff);
  __pyx_r = __pyx_v_ocoeff;
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":365
 *         CHKERR( FNRationalSetNumerator(self.fn, na, a) )
 * 
 *     def getRationalNumerator(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the coefficients of the numerator of the rational function.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.getRationalNumerator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_ocoeff);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":384
 *         return ocoeff
 * 
 *     def setRationalDenominator(self, alpha):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the coefficients of the denominator of the rational function.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_45setRationalDenominator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_44setRationalDenominator[] = "FN.setRationalDenominator(self, alpha)\n\n        Sets the coefficients of the denominator of the rational function.\n\n        Parameters\n        ----------\n        alpha: array of scalars\n            Coefficients.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_45setRationalDenominator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_alpha = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRationalDenominator (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alpha,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRationalDenominator") < 0)) __PYX_ERR(15, 384, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_alpha = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRationalDenominator", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 384, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setRationalDenominator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_44setRationalDenominator(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_alpha);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_44setRationalDenominator(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_alpha) {
  PetscInt __pyx_v_na;
  PetscScalar *__pyx_v_a;
  CYTHON_UNUSED PyObject *__pyx_v_tmp1 = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRationalDenominator", 0);

  /* "SLEPc/FN.pyx":393
 *             Coefficients.
 *         """
 *         cdef PetscInt na = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar *a = NULL
 *         cdef object tmp1 = iarray_s(alpha, &na, &a)
 */
  __pyx_v_na = 0;

  /* "SLEPc/FN.pyx":394
 *         """
 *         cdef PetscInt na = 0
 *         cdef PetscScalar *a = NULL             # <<<<<<<<<<<<<<
 *         cdef object tmp1 = iarray_s(alpha, &na, &a)
 *         CHKERR( FNRationalSetDenominator(self.fn, na, a) )
 */
  __pyx_v_a = NULL;

  /* "SLEPc/FN.pyx":395
 *         cdef PetscInt na = 0
 *         cdef PetscScalar *a = NULL
 *         cdef object tmp1 = iarray_s(alpha, &na, &a)             # <<<<<<<<<<<<<<
 *         CHKERR( FNRationalSetDenominator(self.fn, na, a) )
 * 
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_iarray_s(__pyx_v_alpha, (&__pyx_v_na), (&__pyx_v_a))); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 395, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_tmp1 = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/FN.pyx":396
 *         cdef PetscScalar *a = NULL
 *         cdef object tmp1 = iarray_s(alpha, &na, &a)
 *         CHKERR( FNRationalSetDenominator(self.fn, na, a) )             # <<<<<<<<<<<<<<
 * 
 *     def getRationalDenominator(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNRationalSetDenominator(__pyx_v_self->fn, __pyx_v_na, __pyx_v_a)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(15, 396, __pyx_L1_error)

  /* "SLEPc/FN.pyx":384
 *         return ocoeff
 * 
 *     def setRationalDenominator(self, alpha):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the coefficients of the denominator of the rational function.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setRationalDenominator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":398
 *         CHKERR( FNRationalSetDenominator(self.fn, na, a) )
 * 
 *     def getRationalDenominator(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the coefficients of the denominator of the rational function.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_47getRationalDenominator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_46getRationalDenominator[] = "FN.getRationalDenominator(self)\n\n        Gets the coefficients of the denominator of the rational function.\n\n        Returns\n        -------\n        alpha: array of scalars\n            Coefficients.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_47getRationalDenominator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRationalDenominator (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRationalDenominator", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRationalDenominator", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_46getRationalDenominator(((struct PySlepcFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_46getRationalDenominator(struct PySlepcFNObject *__pyx_v_self) {
  PetscInt __pyx_v_np;
  PetscScalar *__pyx_v_coeff;
  PyObject *__pyx_v_ocoeff = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  char const *__pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  PyObject *__pyx_t_10 = NULL;
  int __pyx_t_11;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRationalDenominator", 0);

  /* "SLEPc/FN.pyx":407
 *             Coefficients.
 *         """
 *         cdef PetscInt np = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar *coeff = NULL
 *         CHKERR( FNRationalGetDenominator(self.fn, &np, &coeff) )
 */
  __pyx_v_np = 0;

  /* "SLEPc/FN.pyx":408
 *         """
 *         cdef PetscInt np = 0
 *         cdef PetscScalar *coeff = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( FNRationalGetDenominator(self.fn, &np, &coeff) )
 *         cdef object ocoeff = None
 */
  __pyx_v_coeff = NULL;

  /* "SLEPc/FN.pyx":409
 *         cdef PetscInt np = 0
 *         cdef PetscScalar *coeff = NULL
 *         CHKERR( FNRationalGetDenominator(self.fn, &np, &coeff) )             # <<<<<<<<<<<<<<
 *         cdef object ocoeff = None
 *         try:
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNRationalGetDenominator(__pyx_v_self->fn, (&__pyx_v_np), (&__pyx_v_coeff))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(15, 409, __pyx_L1_error)

  /* "SLEPc/FN.pyx":410
 *         cdef PetscScalar *coeff = NULL
 *         CHKERR( FNRationalGetDenominator(self.fn, &np, &coeff) )
 *         cdef object ocoeff = None             # <<<<<<<<<<<<<<
 *         try:
 *             ocoeff = array_s(np, coeff)
 */
  __Pyx_INCREF(Py_None);
  __pyx_v_ocoeff = Py_None;

  /* "SLEPc/FN.pyx":411
 *         CHKERR( FNRationalGetDenominator(self.fn, &np, &coeff) )
 *         cdef object ocoeff = None
 *         try:             # <<<<<<<<<<<<<<
 *             ocoeff = array_s(np, coeff)
 *         finally:
 */
  /*try:*/ {

    /* "SLEPc/FN.pyx":412
 *         cdef object ocoeff = None
 *         try:
 *             ocoeff = array_s(np, coeff)             # <<<<<<<<<<<<<<
 *         finally:
 *             CHKERR( PetscFree(coeff) )
 */
    __pyx_t_2 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_s(__pyx_v_np, __pyx_v_coeff)); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 412, __pyx_L4_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_ocoeff, __pyx_t_2);
    __pyx_t_2 = 0;
  }

  /* "SLEPc/FN.pyx":414
 *             ocoeff = array_s(np, coeff)
 *         finally:
 *             CHKERR( PetscFree(coeff) )             # <<<<<<<<<<<<<<
 *         return ocoeff
 * 
 */
  /*finally:*/ {
    /*normal exit:*/{
      __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_coeff)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(15, 414, __pyx_L1_error)
      goto __pyx_L5;
    }
    __pyx_L4_error:;
    /*exception exit:*/{
      __Pyx_PyThreadState_declare
      __Pyx_PyThreadState_assign
      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_5);
      __Pyx_XGOTREF(__pyx_t_6);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_8);
      __Pyx_XGOTREF(__pyx_t_9);
      __Pyx_XGOTREF(__pyx_t_10);
      __pyx_t_1 = __pyx_lineno; __pyx_t_3 = __pyx_clineno; __pyx_t_4 = __pyx_filename;
      {
        __pyx_t_11 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_coeff)); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(15, 414, __pyx_L7_error)
      }
      if (PY_MAJOR_VERSION >= 3) {
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
      }
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_XGIVEREF(__pyx_t_7);
      __Pyx_ErrRestore(__pyx_t_5, __pyx_t_6, __pyx_t_7);
      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      __pyx_lineno = __pyx_t_1; __pyx_clineno = __pyx_t_3; __pyx_filename = __pyx_t_4;
      goto __pyx_L1_error;
      __pyx_L7_error:;
      if (PY_MAJOR_VERSION >= 3) {
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
      }
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      goto __pyx_L1_error;
    }
    __pyx_L5:;
  }

  /* "SLEPc/FN.pyx":415
 *         finally:
 *             CHKERR( PetscFree(coeff) )
 *         return ocoeff             # <<<<<<<<<<<<<<
 * 
 *     def setCombineChildren(self, comb, FN f1, FN f2):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_ocoeff);
  __pyx_r = __pyx_v_ocoeff;
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":398
 *         CHKERR( FNRationalSetDenominator(self.fn, na, a) )
 * 
 *     def getRationalDenominator(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the coefficients of the denominator of the rational function.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.getRationalDenominator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_ocoeff);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":417
 *         return ocoeff
 * 
 *     def setCombineChildren(self, comb, FN f1, FN f2):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the two child functions that constitute this combined
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_49setCombineChildren(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_48setCombineChildren[] = "FN.setCombineChildren(self, comb, FN f1, FN f2)\n\n        Sets the two child functions that constitute this combined\n        function, and the way they must be combined.\n\n        Parameters\n        ----------\n        comb: `FN.CombineType` enumerate\n            How to combine the functions (addition, multiplication, division, composition).\n        f1: FN\n            First function.\n        f2: FN\n            Second function.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_49setCombineChildren(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comb = 0;
  struct PySlepcFNObject *__pyx_v_f1 = 0;
  struct PySlepcFNObject *__pyx_v_f2 = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCombineChildren (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comb,&__pyx_n_s_f1,&__pyx_n_s_f2,0};
    PyObject* values[3] = {0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comb)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_f1)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setCombineChildren", 1, 3, 3, 1); __PYX_ERR(15, 417, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_f2)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setCombineChildren", 1, 3, 3, 2); __PYX_ERR(15, 417, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCombineChildren") < 0)) __PYX_ERR(15, 417, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
    }
    __pyx_v_comb = values[0];
    __pyx_v_f1 = ((struct PySlepcFNObject *)values[1]);
    __pyx_v_f2 = ((struct PySlepcFNObject *)values[2]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCombineChildren", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 417, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setCombineChildren", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_f1), __pyx_ptype_8slepc4py_5SLEPc_FN, 0, "f1", 0))) __PYX_ERR(15, 417, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_f2), __pyx_ptype_8slepc4py_5SLEPc_FN, 0, "f2", 0))) __PYX_ERR(15, 417, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_48setCombineChildren(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_comb, __pyx_v_f1, __pyx_v_f2);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_48setCombineChildren(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_comb, struct PySlepcFNObject *__pyx_v_f1, struct PySlepcFNObject *__pyx_v_f2) {
  FNCombineType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  FNCombineType __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCombineChildren", 0);

  /* "SLEPc/FN.pyx":431
 *             Second function.
 *         """
 *         cdef SlepcFNCombineType val = comb             # <<<<<<<<<<<<<<
 *         CHKERR( FNCombineSetChildren(self.fn, val, f1.fn, f2.fn) )
 * 
 */
  __pyx_t_1 = ((FNCombineType)__Pyx_PyInt_As_FNCombineType(__pyx_v_comb)); if (unlikely(PyErr_Occurred())) __PYX_ERR(15, 431, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/FN.pyx":432
 *         """
 *         cdef SlepcFNCombineType val = comb
 *         CHKERR( FNCombineSetChildren(self.fn, val, f1.fn, f2.fn) )             # <<<<<<<<<<<<<<
 * 
 *     def getCombineChildren(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNCombineSetChildren(__pyx_v_self->fn, __pyx_v_val, __pyx_v_f1->fn, __pyx_v_f2->fn)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(15, 432, __pyx_L1_error)

  /* "SLEPc/FN.pyx":417
 *         return ocoeff
 * 
 *     def setCombineChildren(self, comb, FN f1, FN f2):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the two child functions that constitute this combined
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setCombineChildren", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":434
 *         CHKERR( FNCombineSetChildren(self.fn, val, f1.fn, f2.fn) )
 * 
 *     def getCombineChildren(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the two child functions that constitute this combined
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_51getCombineChildren(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_50getCombineChildren[] = "FN.getCombineChildren(self)\n\n        Gets the two child functions that constitute this combined\n        function, and the way they must be combined.\n\n        Returns\n        -------\n        comb: `FN.CombineType` enumerate\n            How to combine the functions (addition, multiplication, division, composition).\n        f1: FN\n            First function.\n        f2: FN\n            Second function.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_51getCombineChildren(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCombineChildren (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCombineChildren", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCombineChildren", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_50getCombineChildren(((struct PySlepcFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_50getCombineChildren(struct PySlepcFNObject *__pyx_v_self) {
  FNCombineType __pyx_v_comb;
  struct PySlepcFNObject *__pyx_v_f1 = 0;
  struct PySlepcFNObject *__pyx_v_f2 = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCombineChildren", 0);

  /* "SLEPc/FN.pyx":449
 *         """
 *         cdef SlepcFNCombineType comb
 *         cdef FN f1 = FN()             # <<<<<<<<<<<<<<
 *         cdef FN f2 = FN()
 *         CHKERR( FNCombineGetChildren(self.fn, &comb, &f1.fn, &f2.fn) )
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_FN)); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 449, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_f1 = ((struct PySlepcFNObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/FN.pyx":450
 *         cdef SlepcFNCombineType comb
 *         cdef FN f1 = FN()
 *         cdef FN f2 = FN()             # <<<<<<<<<<<<<<
 *         CHKERR( FNCombineGetChildren(self.fn, &comb, &f1.fn, &f2.fn) )
 *         PetscINCREF(f1.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_FN)); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 450, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_f2 = ((struct PySlepcFNObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/FN.pyx":451
 *         cdef FN f1 = FN()
 *         cdef FN f2 = FN()
 *         CHKERR( FNCombineGetChildren(self.fn, &comb, &f1.fn, &f2.fn) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(f1.obj)
 *         PetscINCREF(f2.obj)
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNCombineGetChildren(__pyx_v_self->fn, (&__pyx_v_comb), (&__pyx_v_f1->fn), (&__pyx_v_f2->fn))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(15, 451, __pyx_L1_error)

  /* "SLEPc/FN.pyx":452
 *         cdef FN f2 = FN()
 *         CHKERR( FNCombineGetChildren(self.fn, &comb, &f1.fn, &f2.fn) )
 *         PetscINCREF(f1.obj)             # <<<<<<<<<<<<<<
 *         PetscINCREF(f2.obj)
 *         return (comb, f1, f2)
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_f1->__pyx_base.obj));

  /* "SLEPc/FN.pyx":453
 *         CHKERR( FNCombineGetChildren(self.fn, &comb, &f1.fn, &f2.fn) )
 *         PetscINCREF(f1.obj)
 *         PetscINCREF(f2.obj)             # <<<<<<<<<<<<<<
 *         return (comb, f1, f2)
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_f2->__pyx_base.obj));

  /* "SLEPc/FN.pyx":454
 *         PetscINCREF(f1.obj)
 *         PetscINCREF(f2.obj)
 *         return (comb, f1, f2)             # <<<<<<<<<<<<<<
 * 
 *     def setPhiIndex(self, k):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyInt_From_FNCombineType(__pyx_v_comb); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 454, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 454, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
  __Pyx_INCREF(((PyObject *)__pyx_v_f1));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_f1));
  PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v_f1));
  __Pyx_INCREF(((PyObject *)__pyx_v_f2));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_f2));
  PyTuple_SET_ITEM(__pyx_t_3, 2, ((PyObject *)__pyx_v_f2));
  __pyx_t_1 = 0;
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":434
 *         CHKERR( FNCombineSetChildren(self.fn, val, f1.fn, f2.fn) )
 * 
 *     def getCombineChildren(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the two child functions that constitute this combined
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.getCombineChildren", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_f1);
  __Pyx_XDECREF((PyObject *)__pyx_v_f2);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":456
 *         return (comb, f1, f2)
 * 
 *     def setPhiIndex(self, k):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the index of the phi-function.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_53setPhiIndex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_52setPhiIndex[] = "FN.setPhiIndex(self, k)\n\n        Sets the index of the phi-function.\n\n        Parameters\n        ----------\n        k: int\n           The index.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_53setPhiIndex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_k = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setPhiIndex (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_k,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_k)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setPhiIndex") < 0)) __PYX_ERR(15, 456, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_k = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setPhiIndex", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 456, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setPhiIndex", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_52setPhiIndex(((struct PySlepcFNObject *)__pyx_v_self), __pyx_v_k);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_52setPhiIndex(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_k) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setPhiIndex", 0);

  /* "SLEPc/FN.pyx":465
 *            The index.
 *         """
 *         cdef PetscInt val = asInt(k)             # <<<<<<<<<<<<<<
 *         CHKERR( FNPhiSetIndex(self.fn, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_k); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(15, 465, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/FN.pyx":466
 *         """
 *         cdef PetscInt val = asInt(k)
 *         CHKERR( FNPhiSetIndex(self.fn, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getPhiIndex(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNPhiSetIndex(__pyx_v_self->fn, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(15, 466, __pyx_L1_error)

  /* "SLEPc/FN.pyx":456
 *         return (comb, f1, f2)
 * 
 *     def setPhiIndex(self, k):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the index of the phi-function.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.setPhiIndex", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":468
 *         CHKERR( FNPhiSetIndex(self.fn, val) )
 * 
 *     def getPhiIndex(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the index of the phi-function.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_55getPhiIndex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2FN_54getPhiIndex[] = "FN.getPhiIndex(self)\n\n        Gets the index of the phi-function.\n\n        Returns\n        -------\n        k: int\n           The index.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_55getPhiIndex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getPhiIndex (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getPhiIndex", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getPhiIndex", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_54getPhiIndex(((struct PySlepcFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_54getPhiIndex(struct PySlepcFNObject *__pyx_v_self) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getPhiIndex", 0);

  /* "SLEPc/FN.pyx":477
 *            The index.
 *         """
 *         cdef PetscInt val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( FNPhiGetIndex(self.fn, &val) )
 *         return toInt(val)
 */
  __pyx_v_val = 0;

  /* "SLEPc/FN.pyx":478
 *         """
 *         cdef PetscInt val = 0
 *         CHKERR( FNPhiGetIndex(self.fn, &val) )             # <<<<<<<<<<<<<<
 *         return toInt(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(FNPhiGetIndex(__pyx_v_self->fn, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(15, 478, __pyx_L1_error)

  /* "SLEPc/FN.pyx":479
 *         cdef PetscInt val = 0
 *         CHKERR( FNPhiGetIndex(self.fn, &val) )
 *         return toInt(val)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 479, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":468
 *         CHKERR( FNPhiSetIndex(self.fn, val) )
 * 
 *     def getPhiIndex(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the index of the phi-function.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.getPhiIndex", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":484
 * 
 *     property method:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getMethod()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_6method_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_6method_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_6method___get__(((struct PySlepcFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_6method___get__(struct PySlepcFNObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/FN.pyx":485
 *     property method:
 *         def __get__(self):
 *             return self.getMethod()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setMethod(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getMethod); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 485, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 485, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":484
 * 
 *     property method:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getMethod()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.method.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":486
 *         def __get__(self):
 *             return self.getMethod()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setMethod(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2FN_6method_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2FN_6method_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_6method_2__set__(((struct PySlepcFNObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2FN_6method_2__set__(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/FN.pyx":487
 *             return self.getMethod()
 *         def __set__(self, value):
 *             self.setMethod(value)             # <<<<<<<<<<<<<<
 * 
 *     property parallel:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setMethod); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 487, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 487, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/FN.pyx":486
 *         def __get__(self):
 *             return self.getMethod()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setMethod(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.method.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":490
 * 
 *     property parallel:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getParallel()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_8parallel_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2FN_8parallel_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_8parallel___get__(((struct PySlepcFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2FN_8parallel___get__(struct PySlepcFNObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/FN.pyx":491
 *     property parallel:
 *         def __get__(self):
 *             return self.getParallel()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setParallel(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getParallel); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 491, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 491, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/FN.pyx":490
 * 
 *     property parallel:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getParallel()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.parallel.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/FN.pyx":492
 *         def __get__(self):
 *             return self.getParallel()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setParallel(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2FN_8parallel_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2FN_8parallel_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2FN_8parallel_2__set__(((struct PySlepcFNObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2FN_8parallel_2__set__(struct PySlepcFNObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/FN.pyx":493
 *             return self.getParallel()
 *         def __set__(self, value):
 *             self.setParallel(value)             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setParallel); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 493, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 493, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/FN.pyx":492
 *         def __get__(self):
 *             return self.getParallel()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setParallel(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.FN.parallel.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":33
 *     QuadRule = RGQuadRule
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.rg
 *         self.rg = NULL
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2RG_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2RG_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG___cinit__(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2RG___cinit__(struct PySlepcRGObject *__pyx_v_self) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "SLEPc/RG.pyx":34
 * 
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.rg             # <<<<<<<<<<<<<<
 *         self.rg = NULL
 * 
 */
  __pyx_v_self->__pyx_base.obj = ((PetscObject *)(&__pyx_v_self->rg));

  /* "SLEPc/RG.pyx":35
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.rg
 *         self.rg = NULL             # <<<<<<<<<<<<<<
 * 
 *     def view(self, Viewer viewer=None):
 */
  __pyx_v_self->rg = NULL;

  /* "SLEPc/RG.pyx":33
 *     QuadRule = RGQuadRule
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.rg
 *         self.rg = NULL
 */

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":37
 *         self.rg = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the RG data structure.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_2view[] = "RG.view(self, Viewer viewer=None)\n\n        Prints the RG data structure.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("view (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "view") < 0)) __PYX_ERR(16, 37, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("view", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 37, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(16, 37, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_2view(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_2view(struct PySlepcRGObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("view", 0);

  /* "SLEPc/RG.pyx":47
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( RGView(self.rg, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/RG.pyx":48
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( RGView(self.rg, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def destroy(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGView(__pyx_v_self->rg, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 48, __pyx_L1_error)

  /* "SLEPc/RG.pyx":37
 *         self.rg = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the RG data structure.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":50
 *         CHKERR( RGView(self.rg, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the RG object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_4destroy[] = "RG.destroy(self)\n\n        Destroys the RG object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("destroy (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("destroy", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "destroy", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_4destroy(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_4destroy(struct PySlepcRGObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("destroy", 0);

  /* "SLEPc/RG.pyx":54
 *         Destroys the RG object.
 *         """
 *         CHKERR( RGDestroy(&self.rg) )             # <<<<<<<<<<<<<<
 *         self.rg = NULL
 *         return self
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGDestroy((&__pyx_v_self->rg))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 54, __pyx_L1_error)

  /* "SLEPc/RG.pyx":55
 *         """
 *         CHKERR( RGDestroy(&self.rg) )
 *         self.rg = NULL             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  __pyx_v_self->rg = NULL;

  /* "SLEPc/RG.pyx":56
 *         CHKERR( RGDestroy(&self.rg) )
 *         self.rg = NULL
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def create(self, comm=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":50
 *         CHKERR( RGView(self.rg, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the RG object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.destroy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":58
 *         return self
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the RG object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_7create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_6create[] = "RG.create(self, comm=None)\n\n        Creates the RG object.\n\n        Parameters\n        ----------\n        comm: Comm, optional\n              MPI communicator; if not provided, it defaults to all\n              processes.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_7create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comm = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comm,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comm);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create") < 0)) __PYX_ERR(16, 58, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_comm = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("create", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 58, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_6create(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_comm);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_6create(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_comm) {
  MPI_Comm __pyx_v_ccomm;
  RG __pyx_v_newrg;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  MPI_Comm __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("create", 0);

  /* "SLEPc/RG.pyx":68
 *               processes.
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())             # <<<<<<<<<<<<<<
 *         cdef SlepcRG newrg = NULL
 *         CHKERR( RGCreate(ccomm, &newrg) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_def_Comm(__pyx_v_comm, __pyx_f_8slepc4py_5SLEPc_SLEPC_COMM_DEFAULT()); if (unlikely(PyErr_Occurred())) __PYX_ERR(16, 68, __pyx_L1_error)
  __pyx_v_ccomm = __pyx_t_1;

  /* "SLEPc/RG.pyx":69
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcRG newrg = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( RGCreate(ccomm, &newrg) )
 *         SlepcCLEAR(self.obj); self.rg = newrg
 */
  __pyx_v_newrg = NULL;

  /* "SLEPc/RG.pyx":70
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcRG newrg = NULL
 *         CHKERR( RGCreate(ccomm, &newrg) )             # <<<<<<<<<<<<<<
 *         SlepcCLEAR(self.obj); self.rg = newrg
 *         return self
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGCreate(__pyx_v_ccomm, (&__pyx_v_newrg))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(16, 70, __pyx_L1_error)

  /* "SLEPc/RG.pyx":71
 *         cdef SlepcRG newrg = NULL
 *         CHKERR( RGCreate(ccomm, &newrg) )
 *         SlepcCLEAR(self.obj); self.rg = newrg             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_SlepcCLEAR(__pyx_v_self->__pyx_base.obj));
  __pyx_v_self->rg = __pyx_v_newrg;

  /* "SLEPc/RG.pyx":72
 *         CHKERR( RGCreate(ccomm, &newrg) )
 *         SlepcCLEAR(self.obj); self.rg = newrg
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def setType(self, rg_type):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":58
 *         return self
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the RG object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":74
 *         return self
 * 
 *     def setType(self, rg_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the type for the RG object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_9setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_8setType[] = "RG.setType(self, rg_type)\n\n        Selects the type for the RG object.\n\n        Parameters\n        ----------\n        rg_type: `RG.Type` enumerate\n                  The inner product type to be used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_9setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_rg_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rg_type,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rg_type)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setType") < 0)) __PYX_ERR(16, 74, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_rg_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 74, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_8setType(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_rg_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_8setType(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_rg_type) {
  const char* __pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setType", 0);
  __Pyx_INCREF(__pyx_v_rg_type);

  /* "SLEPc/RG.pyx":83
 *                   The inner product type to be used.
 *         """
 *         cdef SlepcRGType cval = NULL             # <<<<<<<<<<<<<<
 *         rg_type = str2bytes(rg_type, &cval)
 *         CHKERR( RGSetType(self.rg, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/RG.pyx":84
 *         """
 *         cdef SlepcRGType cval = NULL
 *         rg_type = str2bytes(rg_type, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( RGSetType(self.rg, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_rg_type, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 84, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_rg_type, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/RG.pyx":85
 *         cdef SlepcRGType cval = NULL
 *         rg_type = str2bytes(rg_type, &cval)
 *         CHKERR( RGSetType(self.rg, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getType(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGSetType(__pyx_v_self->rg, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(16, 85, __pyx_L1_error)

  /* "SLEPc/RG.pyx":74
 *         return self
 * 
 *     def setType(self, rg_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the type for the RG object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_rg_type);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":87
 *         CHKERR( RGSetType(self.rg, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the RG type of this object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_11getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_10getType[] = "RG.getType(self)\n\n        Gets the RG type of this object.\n\n        Returns\n        -------\n        type: `RG.Type` enumerate\n              The inner product type currently being used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_11getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_10getType(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_10getType(struct PySlepcRGObject *__pyx_v_self) {
  const char* __pyx_v_rg_type;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getType", 0);

  /* "SLEPc/RG.pyx":96
 *               The inner product type currently being used.
 *         """
 *         cdef SlepcRGType rg_type = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( RGGetType(self.rg, &rg_type) )
 *         return bytes2str(rg_type)
 */
  __pyx_v_rg_type = NULL;

  /* "SLEPc/RG.pyx":97
 *         """
 *         cdef SlepcRGType rg_type = NULL
 *         CHKERR( RGGetType(self.rg, &rg_type) )             # <<<<<<<<<<<<<<
 *         return bytes2str(rg_type)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGGetType(__pyx_v_self->rg, (&__pyx_v_rg_type))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 97, __pyx_L1_error)

  /* "SLEPc/RG.pyx":98
 *         cdef SlepcRGType rg_type = NULL
 *         CHKERR( RGGetType(self.rg, &rg_type) )
 *         return bytes2str(rg_type)             # <<<<<<<<<<<<<<
 * 
 *     def setOptionsPrefix(self, prefix):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_rg_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 98, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":87
 *         CHKERR( RGSetType(self.rg, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the RG type of this object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.getType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":100
 *         return bytes2str(rg_type)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all RG options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_13setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_12setOptionsPrefix[] = "RG.setOptionsPrefix(self, prefix)\n\n        Sets the prefix used for searching for all RG options in the\n        database.\n\n        Parameters\n        ----------\n        prefix: string\n                The prefix string to prepend to all RG option\n                requests.\n\n        Notes\n        -----\n        A hyphen (``-``) must NOT be given at the beginning of the\n        prefix name.  The first character of all runtime options is\n        AUTOMATICALLY the hyphen.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_13setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOptionsPrefix") < 0)) __PYX_ERR(16, 100, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 100, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_12setOptionsPrefix(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_12setOptionsPrefix(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/RG.pyx":117
 *         AUTOMATICALLY the hyphen.
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( RGSetOptionsPrefix(self.rg, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/RG.pyx":118
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( RGSetOptionsPrefix(self.rg, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 118, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/RG.pyx":119
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( RGSetOptionsPrefix(self.rg, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getOptionsPrefix(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGSetOptionsPrefix(__pyx_v_self->rg, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(16, 119, __pyx_L1_error)

  /* "SLEPc/RG.pyx":100
 *         return bytes2str(rg_type)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all RG options in the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":121
 *         CHKERR( RGSetOptionsPrefix(self.rg, cval) )
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all RG options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_15getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_14getOptionsPrefix[] = "RG.getOptionsPrefix(self)\n\n        Gets the prefix used for searching for all RG options in the\n        database.\n\n        Returns\n        -------\n        prefix: string\n                The prefix string set for this RG object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_15getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOptionsPrefix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOptionsPrefix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOptionsPrefix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_14getOptionsPrefix(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_14getOptionsPrefix(struct PySlepcRGObject *__pyx_v_self) {
  const char *__pyx_v_prefix;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOptionsPrefix", 0);

  /* "SLEPc/RG.pyx":131
 *                 The prefix string set for this RG object.
 *         """
 *         cdef const_char *prefix = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( RGGetOptionsPrefix(self.rg, &prefix) )
 *         return bytes2str(prefix)
 */
  __pyx_v_prefix = NULL;

  /* "SLEPc/RG.pyx":132
 *         """
 *         cdef const_char *prefix = NULL
 *         CHKERR( RGGetOptionsPrefix(self.rg, &prefix) )             # <<<<<<<<<<<<<<
 *         return bytes2str(prefix)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGGetOptionsPrefix(__pyx_v_self->rg, (&__pyx_v_prefix))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 132, __pyx_L1_error)

  /* "SLEPc/RG.pyx":133
 *         cdef const_char *prefix = NULL
 *         CHKERR( RGGetOptionsPrefix(self.rg, &prefix) )
 *         return bytes2str(prefix)             # <<<<<<<<<<<<<<
 * 
 *     def setFromOptions(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_prefix); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 133, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":121
 *         CHKERR( RGSetOptionsPrefix(self.rg, cval) )
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all RG options in the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.getOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":135
 *         return bytes2str(prefix)
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets RG options from the options database.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_17setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_16setFromOptions[] = "RG.setFromOptions(self)\n\n        Sets RG options from the options database.\n\n        Notes\n        -----\n        To see all options, run your program with the ``-help``\n        option.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_17setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFromOptions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setFromOptions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setFromOptions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_16setFromOptions(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_16setFromOptions(struct PySlepcRGObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFromOptions", 0);

  /* "SLEPc/RG.pyx":144
 *         option.
 *         """
 *         CHKERR( RGSetFromOptions(self.rg) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGSetFromOptions(__pyx_v_self->rg)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 144, __pyx_L1_error)

  /* "SLEPc/RG.pyx":135
 *         return bytes2str(prefix)
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets RG options from the options database.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setFromOptions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":148
 *     #
 * 
 *     def isTrivial(self):             # <<<<<<<<<<<<<<
 *         """
 *         Tells whether it is the trivial region (whole complex plane).
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_19isTrivial(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_18isTrivial[] = "RG.isTrivial(self)\n\n        Tells whether it is the trivial region (whole complex plane).\n\n        Returns\n        -------\n        flag: bool\n             True if the region is equal to the whole complex plane, e.g.,\n             an interval region with all four endpoints unbounded or an\n             ellipse with infinite radius.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_19isTrivial(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("isTrivial (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("isTrivial", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isTrivial", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_18isTrivial(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_18isTrivial(struct PySlepcRGObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("isTrivial", 0);

  /* "SLEPc/RG.pyx":159
 *              ellipse with infinite radius.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( RGIsTrivial(self.rg, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/RG.pyx":160
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( RGIsTrivial(self.rg, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGIsTrivial(__pyx_v_self->rg, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 160, __pyx_L1_error)

  /* "SLEPc/RG.pyx":161
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( RGIsTrivial(self.rg, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def isAxisymmetric(self, vertical=False):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 161, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":148
 *     #
 * 
 *     def isTrivial(self):             # <<<<<<<<<<<<<<
 *         """
 *         Tells whether it is the trivial region (whole complex plane).
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.isTrivial", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":163
 *         return toBool(tval)
 * 
 *     def isAxisymmetric(self, vertical=False):             # <<<<<<<<<<<<<<
 *         """
 *         Determines if the region is symmetric with respect to the real
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_21isAxisymmetric(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_20isAxisymmetric[] = "RG.isAxisymmetric(self, vertical=False)\n\n        Determines if the region is symmetric with respect to the real\n        or imaginary axis.\n\n        Parameters\n        ----------\n        vertical: bool, optional\n            True if symmetry must be checked against the vertical axis.\n\n        Returns\n        -------\n        symm: bool\n             True if the region is axisymmetric.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_21isAxisymmetric(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_vertical = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("isAxisymmetric (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_vertical,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_vertical);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "isAxisymmetric") < 0)) __PYX_ERR(16, 163, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_vertical = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("isAxisymmetric", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 163, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.isAxisymmetric", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_20isAxisymmetric(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_vertical);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_20isAxisymmetric(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_vertical) {
  PetscBool __pyx_v_val;
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("isAxisymmetric", 0);

  /* "SLEPc/RG.pyx":178
 *              True if the region is axisymmetric.
 *         """
 *         cdef PetscBool val = asBool(vertical)             # <<<<<<<<<<<<<<
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( RGIsAxisymmetric(self.rg, val, &tval) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_vertical); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(16, 178, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/RG.pyx":179
 *         """
 *         cdef PetscBool val = asBool(vertical)
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( RGIsAxisymmetric(self.rg, val, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/RG.pyx":180
 *         cdef PetscBool val = asBool(vertical)
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( RGIsAxisymmetric(self.rg, val, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGIsAxisymmetric(__pyx_v_self->rg, __pyx_v_val, (&__pyx_v_tval))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(16, 180, __pyx_L1_error)

  /* "SLEPc/RG.pyx":181
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( RGIsAxisymmetric(self.rg, val, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def getComplement(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 181, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":163
 *         return toBool(tval)
 * 
 *     def isAxisymmetric(self, vertical=False):             # <<<<<<<<<<<<<<
 *         """
 *         Determines if the region is symmetric with respect to the real
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.isAxisymmetric", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":183
 *         return toBool(tval)
 * 
 *     def getComplement(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether the region is complemented or not.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_23getComplement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_22getComplement[] = "RG.getComplement(self)\n\n        Returns the flag indicating whether the region is complemented or not.\n\n        Returns\n        -------\n        flg: bool\n            Whether the region is complemented or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_23getComplement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getComplement (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getComplement", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getComplement", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_22getComplement(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_22getComplement(struct PySlepcRGObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getComplement", 0);

  /* "SLEPc/RG.pyx":192
 *             Whether the region is complemented or not.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( RGGetComplement(self.rg, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/RG.pyx":193
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( RGGetComplement(self.rg, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGGetComplement(__pyx_v_self->rg, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 193, __pyx_L1_error)

  /* "SLEPc/RG.pyx":194
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( RGGetComplement(self.rg, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setComplement(self, comp=True):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 194, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":183
 *         return toBool(tval)
 * 
 *     def getComplement(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether the region is complemented or not.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.getComplement", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":196
 *         return toBool(tval)
 * 
 *     def setComplement(self, comp=True):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to indicate that the region is the complement
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_25setComplement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_24setComplement[] = "RG.setComplement(self, comp=True)\n\n        Sets a flag to indicate that the region is the complement\n        of the specified one.\n\n        Parameters\n        ----------\n        comp: bool, optional\n            Activate/deactivate the complementation of the region.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_25setComplement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comp = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setComplement (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comp,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comp);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setComplement") < 0)) __PYX_ERR(16, 196, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_comp = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setComplement", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 196, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setComplement", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_24setComplement(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_comp);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_24setComplement(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_comp) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setComplement", 0);

  /* "SLEPc/RG.pyx":206
 *             Activate/deactivate the complementation of the region.
 *         """
 *         cdef PetscBool tval = asBool(comp)             # <<<<<<<<<<<<<<
 *         CHKERR( RGSetComplement(self.rg, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_comp); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(16, 206, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/RG.pyx":207
 *         """
 *         cdef PetscBool tval = asBool(comp)
 *         CHKERR( RGSetComplement(self.rg, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def setScale(self, sfactor=None):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGSetComplement(__pyx_v_self->rg, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(16, 207, __pyx_L1_error)

  /* "SLEPc/RG.pyx":196
 *         return toBool(tval)
 * 
 *     def setComplement(self, comp=True):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to indicate that the region is the complement
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setComplement", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":209
 *         CHKERR( RGSetComplement(self.rg, tval) )
 * 
 *     def setScale(self, sfactor=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the scaling factor to be used when checking that a
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_27setScale(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_26setScale[] = "RG.setScale(self, sfactor=None)\n\n        Sets the scaling factor to be used when checking that a\n        point is inside the region and when computing the contour.\n\n        Parameters\n        ----------\n        sfactor: float, optional\n                 The scaling factor (default=1).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_27setScale(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_sfactor = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setScale (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sfactor,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sfactor);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setScale") < 0)) __PYX_ERR(16, 209, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_sfactor = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setScale", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 209, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setScale", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_26setScale(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_sfactor);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_26setScale(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_sfactor) {
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscReal __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setScale", 0);

  /* "SLEPc/RG.pyx":219
 *                  The scaling factor (default=1).
 *         """
 *         cdef PetscReal rval = 1.0             # <<<<<<<<<<<<<<
 *         if sfactor is not None: rval = asReal(sfactor)
 *         CHKERR( RGSetScale(self.rg, rval) )
 */
  __pyx_v_rval = 1.0;

  /* "SLEPc/RG.pyx":220
 *         """
 *         cdef PetscReal rval = 1.0
 *         if sfactor is not None: rval = asReal(sfactor)             # <<<<<<<<<<<<<<
 *         CHKERR( RGSetScale(self.rg, rval) )
 * 
 */
  __pyx_t_1 = (__pyx_v_sfactor != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_sfactor); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(16, 220, __pyx_L1_error)
    __pyx_v_rval = __pyx_t_3;
  }

  /* "SLEPc/RG.pyx":221
 *         cdef PetscReal rval = 1.0
 *         if sfactor is not None: rval = asReal(sfactor)
 *         CHKERR( RGSetScale(self.rg, rval) )             # <<<<<<<<<<<<<<
 * 
 *     def getScale(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGSetScale(__pyx_v_self->rg, __pyx_v_rval)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(16, 221, __pyx_L1_error)

  /* "SLEPc/RG.pyx":209
 *         CHKERR( RGSetComplement(self.rg, tval) )
 * 
 *     def setScale(self, sfactor=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the scaling factor to be used when checking that a
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setScale", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":223
 *         CHKERR( RGSetScale(self.rg, rval) )
 * 
 *     def getScale(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the scaling factor.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_29getScale(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_28getScale[] = "RG.getScale(self)\n\n        Gets the scaling factor.\n\n        Returns\n        -------\n        sfactor: float\n                 The scaling factor.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_29getScale(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getScale (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getScale", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getScale", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_28getScale(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_28getScale(struct PySlepcRGObject *__pyx_v_self) {
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getScale", 0);

  /* "SLEPc/RG.pyx":232
 *                  The scaling factor.
 *         """
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( RGGetScale(self.rg, &rval) )
 *         return toReal(rval)
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/RG.pyx":233
 *         """
 *         cdef PetscReal rval = 0
 *         CHKERR( RGGetScale(self.rg, &rval) )             # <<<<<<<<<<<<<<
 *         return toReal(rval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGGetScale(__pyx_v_self->rg, (&__pyx_v_rval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 233, __pyx_L1_error)

  /* "SLEPc/RG.pyx":234
 *         cdef PetscReal rval = 0
 *         CHKERR( RGGetScale(self.rg, &rval) )
 *         return toReal(rval)             # <<<<<<<<<<<<<<
 * 
 *     def checkInside(self, a):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":223
 *         CHKERR( RGSetScale(self.rg, rval) )
 * 
 *     def getScale(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the scaling factor.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.getScale", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":236
 *         return toReal(rval)
 * 
 *     def checkInside(self, a):             # <<<<<<<<<<<<<<
 *         """
 *         Determines if a set of given points are inside the region or not.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_31checkInside(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_30checkInside[] = "RG.checkInside(self, a)\n\n        Determines if a set of given points are inside the region or not.\n\n        Parameters\n        ----------\n        a: list of float (complex)\n           The coordinates of the points.\n\n        Returns\n        -------\n        inside: list of int\n                Computed result for each point (1=inside, 0=on the contour, -1=outside).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_31checkInside(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_a = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("checkInside (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_a,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_a)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "checkInside") < 0)) __PYX_ERR(16, 236, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_a = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("checkInside", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 236, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.checkInside", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_30checkInside(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_a);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_30checkInside(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_a) {
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_n;
  PetscScalar *__pyx_v_ar;
  PetscScalar *__pyx_v_ai;
  PetscInt *__pyx_v_inside;
  CYTHON_UNUSED PyObject *__pyx_v_tmp1 = 0;
  CYTHON_UNUSED PyObject *__pyx_v_tmp2 = 0;
  CYTHON_UNUSED PyObject *__pyx_v_tmp3 = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Py_ssize_t __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  PetscReal __pyx_t_6;
  PetscScalar __pyx_t_7;
  int __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("checkInside", 0);

  /* "SLEPc/RG.pyx":250
 *                 Computed result for each point (1=inside, 0=on the contour, -1=outside).
 *         """
 *         cdef Py_ssize_t i = 0, n = len(a)             # <<<<<<<<<<<<<<
 *         cdef PetscScalar *ar = NULL, *ai = NULL
 *         cdef PetscInt *inside = NULL
 */
  __pyx_v_i = 0;
  __pyx_t_1 = PyObject_Length(__pyx_v_a); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(16, 250, __pyx_L1_error)
  __pyx_v_n = __pyx_t_1;

  /* "SLEPc/RG.pyx":251
 *         """
 *         cdef Py_ssize_t i = 0, n = len(a)
 *         cdef PetscScalar *ar = NULL, *ai = NULL             # <<<<<<<<<<<<<<
 *         cdef PetscInt *inside = NULL
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&ar)
 */
  __pyx_v_ar = NULL;
  __pyx_v_ai = NULL;

  /* "SLEPc/RG.pyx":252
 *         cdef Py_ssize_t i = 0, n = len(a)
 *         cdef PetscScalar *ar = NULL, *ai = NULL
 *         cdef PetscInt *inside = NULL             # <<<<<<<<<<<<<<
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&ar)
 *         cdef tmp2
 */
  __pyx_v_inside = NULL;

  /* "SLEPc/RG.pyx":253
 *         cdef PetscScalar *ar = NULL, *ai = NULL
 *         cdef PetscInt *inside = NULL
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&ar)             # <<<<<<<<<<<<<<
 *         cdef tmp2
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_n) * (sizeof(PetscScalar))), ((void **)(&__pyx_v_ar))); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 253, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_tmp1 = __pyx_t_2;
  __pyx_t_2 = 0;

  /* "SLEPc/RG.pyx":255
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&ar)
 *         cdef tmp2
 *         if sizeof(PetscScalar) == sizeof(PetscReal):             # <<<<<<<<<<<<<<
 *             tmp2 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&ai)
 *             for i in range(n):
 */
  __pyx_t_3 = (((sizeof(PetscScalar)) == (sizeof(PetscReal))) != 0);
  if (__pyx_t_3) {

    /* "SLEPc/RG.pyx":256
 *         cdef tmp2
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 *             tmp2 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&ai)             # <<<<<<<<<<<<<<
 *             for i in range(n):
 *                 ar[i] = asComplexReal(a[i])
 */
    __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_n) * (sizeof(PetscScalar))), ((void **)(&__pyx_v_ai))); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 256, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_v_tmp2 = __pyx_t_2;
    __pyx_t_2 = 0;

    /* "SLEPc/RG.pyx":257
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 *             tmp2 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&ai)
 *             for i in range(n):             # <<<<<<<<<<<<<<
 *                 ar[i] = asComplexReal(a[i])
 *                 ai[i] = asComplexImag(a[i])
 */
    __pyx_t_1 = __pyx_v_n;
    __pyx_t_4 = __pyx_t_1;
    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
      __pyx_v_i = __pyx_t_5;

      /* "SLEPc/RG.pyx":258
 *             tmp2 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&ai)
 *             for i in range(n):
 *                 ar[i] = asComplexReal(a[i])             # <<<<<<<<<<<<<<
 *                 ai[i] = asComplexImag(a[i])
 *         else:
 */
      __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_a, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 258, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_asComplexReal(__pyx_t_2); if (unlikely(__pyx_t_6 == ((PetscReal)((PetscReal)(-1.0))) && PyErr_Occurred())) __PYX_ERR(16, 258, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      (__pyx_v_ar[__pyx_v_i]) = __pyx_t_6;

      /* "SLEPc/RG.pyx":259
 *             for i in range(n):
 *                 ar[i] = asComplexReal(a[i])
 *                 ai[i] = asComplexImag(a[i])             # <<<<<<<<<<<<<<
 *         else:
 *             for i in range(n): ar[i] = asScalar(a[i])
 */
      __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_a, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 259, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_asComplexImag(__pyx_t_2); if (unlikely(__pyx_t_6 == ((PetscReal)((PetscReal)(-1.0))) && PyErr_Occurred())) __PYX_ERR(16, 259, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      (__pyx_v_ai[__pyx_v_i]) = __pyx_t_6;
    }

    /* "SLEPc/RG.pyx":255
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&ar)
 *         cdef tmp2
 *         if sizeof(PetscScalar) == sizeof(PetscReal):             # <<<<<<<<<<<<<<
 *             tmp2 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&ai)
 *             for i in range(n):
 */
    goto __pyx_L3;
  }

  /* "SLEPc/RG.pyx":261
 *                 ai[i] = asComplexImag(a[i])
 *         else:
 *             for i in range(n): ar[i] = asScalar(a[i])             # <<<<<<<<<<<<<<
 *         cdef tmp3 = allocate(<size_t>n*sizeof(PetscInt),<void**>&inside)
 *         CHKERR( RGCheckInside(self.rg, <PetscInt>n, ar, ai, inside) )
 */
  /*else*/ {
    __pyx_t_1 = __pyx_v_n;
    __pyx_t_4 = __pyx_t_1;
    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
      __pyx_v_i = __pyx_t_5;
      __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_a, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 261, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_t_2); if (unlikely(__pyx_t_7 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(16, 261, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      (__pyx_v_ar[__pyx_v_i]) = __pyx_t_7;
    }
  }
  __pyx_L3:;

  /* "SLEPc/RG.pyx":262
 *         else:
 *             for i in range(n): ar[i] = asScalar(a[i])
 *         cdef tmp3 = allocate(<size_t>n*sizeof(PetscInt),<void**>&inside)             # <<<<<<<<<<<<<<
 *         CHKERR( RGCheckInside(self.rg, <PetscInt>n, ar, ai, inside) )
 *         return array_i(n, inside)
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_n) * (sizeof(PetscInt))), ((void **)(&__pyx_v_inside))); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 262, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_tmp3 = __pyx_t_2;
  __pyx_t_2 = 0;

  /* "SLEPc/RG.pyx":263
 *             for i in range(n): ar[i] = asScalar(a[i])
 *         cdef tmp3 = allocate(<size_t>n*sizeof(PetscInt),<void**>&inside)
 *         CHKERR( RGCheckInside(self.rg, <PetscInt>n, ar, ai, inside) )             # <<<<<<<<<<<<<<
 *         return array_i(n, inside)
 * 
 */
  __pyx_t_8 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGCheckInside(__pyx_v_self->rg, ((PetscInt)__pyx_v_n), __pyx_v_ar, __pyx_v_ai, __pyx_v_inside)); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(16, 263, __pyx_L1_error)

  /* "SLEPc/RG.pyx":264
 *         cdef tmp3 = allocate(<size_t>n*sizeof(PetscInt),<void**>&inside)
 *         CHKERR( RGCheckInside(self.rg, <PetscInt>n, ar, ai, inside) )
 *         return array_i(n, inside)             # <<<<<<<<<<<<<<
 * 
 *     def computeContour(self, n):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_i(__pyx_v_n, __pyx_v_inside)); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 264, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":236
 *         return toReal(rval)
 * 
 *     def checkInside(self, a):             # <<<<<<<<<<<<<<
 *         """
 *         Determines if a set of given points are inside the region or not.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.checkInside", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp1);
  __Pyx_XDECREF(__pyx_v_tmp2);
  __Pyx_XDECREF(__pyx_v_tmp3);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":266
 *         return array_i(n, inside)
 * 
 *     def computeContour(self, n):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the coordinates of several points lying on the contour
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_33computeContour(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_32computeContour[] = "RG.computeContour(self, n)\n\n        Computes the coordinates of several points lying on the contour\n        of the region.\n\n        Parameters\n        ----------\n        n: int\n           The number of points to compute.\n\n        Returns\n        -------\n        x: list of float (complex)\n           Computed points.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_33computeContour(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_n = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("computeContour (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_n,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "computeContour") < 0)) __PYX_ERR(16, 266, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_n = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("computeContour", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 266, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.computeContour", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_32computeContour(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_n);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_32computeContour(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_n) {
  PetscInt __pyx_v_k;
  CYTHON_UNUSED PetscInt __pyx_v_i;
  PetscScalar *__pyx_v_cr;
  PetscScalar *__pyx_v_ci;
  CYTHON_UNUSED PyObject *__pyx_v_tmp1 = 0;
  CYTHON_UNUSED PyObject *__pyx_v_tmp2 = 0;
  PetscInt __pyx_8genexpr9__pyx_v_i;
  PetscInt __pyx_9genexpr10__pyx_v_i;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  int __pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("computeContour", 0);

  /* "SLEPc/RG.pyx":281
 *            Computed points.
 *         """
 *         cdef PetscInt k = asInt(n), i = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar *cr = NULL, *ci = NULL
 *         cdef tmp1 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&cr)
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_n); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(16, 281, __pyx_L1_error)
  __pyx_v_k = __pyx_t_1;
  __pyx_v_i = 0;

  /* "SLEPc/RG.pyx":282
 *         """
 *         cdef PetscInt k = asInt(n), i = 0
 *         cdef PetscScalar *cr = NULL, *ci = NULL             # <<<<<<<<<<<<<<
 *         cdef tmp1 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&cr)
 *         cdef tmp2
 */
  __pyx_v_cr = NULL;
  __pyx_v_ci = NULL;

  /* "SLEPc/RG.pyx":283
 *         cdef PetscInt k = asInt(n), i = 0
 *         cdef PetscScalar *cr = NULL, *ci = NULL
 *         cdef tmp1 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&cr)             # <<<<<<<<<<<<<<
 *         cdef tmp2
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_k) * (sizeof(PetscScalar))), ((void **)(&__pyx_v_cr))); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 283, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_tmp1 = __pyx_t_2;
  __pyx_t_2 = 0;

  /* "SLEPc/RG.pyx":285
 *         cdef tmp1 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&cr)
 *         cdef tmp2
 *         if sizeof(PetscScalar) == sizeof(PetscReal):             # <<<<<<<<<<<<<<
 *             tmp2 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&ci)
 *         CHKERR( RGComputeContour(self.rg, k, cr, ci) )
 */
  __pyx_t_3 = (((sizeof(PetscScalar)) == (sizeof(PetscReal))) != 0);
  if (__pyx_t_3) {

    /* "SLEPc/RG.pyx":286
 *         cdef tmp2
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 *             tmp2 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&ci)             # <<<<<<<<<<<<<<
 *         CHKERR( RGComputeContour(self.rg, k, cr, ci) )
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 */
    __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_k) * (sizeof(PetscScalar))), ((void **)(&__pyx_v_ci))); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_v_tmp2 = __pyx_t_2;
    __pyx_t_2 = 0;

    /* "SLEPc/RG.pyx":285
 *         cdef tmp1 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&cr)
 *         cdef tmp2
 *         if sizeof(PetscScalar) == sizeof(PetscReal):             # <<<<<<<<<<<<<<
 *             tmp2 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&ci)
 *         CHKERR( RGComputeContour(self.rg, k, cr, ci) )
 */
  }

  /* "SLEPc/RG.pyx":287
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 *             tmp2 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&ci)
 *         CHKERR( RGComputeContour(self.rg, k, cr, ci) )             # <<<<<<<<<<<<<<
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 *             return [toComplex(cr[i],ci[i]) for i from 0 <= i <k]
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGComputeContour(__pyx_v_self->rg, __pyx_v_k, __pyx_v_cr, __pyx_v_ci)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(16, 287, __pyx_L1_error)

  /* "SLEPc/RG.pyx":288
 *             tmp2 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&ci)
 *         CHKERR( RGComputeContour(self.rg, k, cr, ci) )
 *         if sizeof(PetscScalar) == sizeof(PetscReal):             # <<<<<<<<<<<<<<
 *             return [toComplex(cr[i],ci[i]) for i from 0 <= i <k]
 *         else:
 */
  __pyx_t_3 = (((sizeof(PetscScalar)) == (sizeof(PetscReal))) != 0);
  if (__pyx_t_3) {

    /* "SLEPc/RG.pyx":289
 *         CHKERR( RGComputeContour(self.rg, k, cr, ci) )
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 *             return [toComplex(cr[i],ci[i]) for i from 0 <= i <k]             # <<<<<<<<<<<<<<
 *         else:
 *             return [toScalar(cr[i]) for i from 0 <= i <k]
 */
    __Pyx_XDECREF(__pyx_r);
    { /* enter inner scope */
      __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 289, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_1 = __pyx_v_k;
      for (__pyx_8genexpr9__pyx_v_i = 0; __pyx_8genexpr9__pyx_v_i < __pyx_t_1; __pyx_8genexpr9__pyx_v_i++) {
        __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toComplex((__pyx_v_cr[__pyx_8genexpr9__pyx_v_i]), (__pyx_v_ci[__pyx_8genexpr9__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 289, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_5))) __PYX_ERR(16, 289, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      }
    } /* exit inner scope */
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;

    /* "SLEPc/RG.pyx":288
 *             tmp2 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&ci)
 *         CHKERR( RGComputeContour(self.rg, k, cr, ci) )
 *         if sizeof(PetscScalar) == sizeof(PetscReal):             # <<<<<<<<<<<<<<
 *             return [toComplex(cr[i],ci[i]) for i from 0 <= i <k]
 *         else:
 */
  }

  /* "SLEPc/RG.pyx":291
 *             return [toComplex(cr[i],ci[i]) for i from 0 <= i <k]
 *         else:
 *             return [toScalar(cr[i]) for i from 0 <= i <k]             # <<<<<<<<<<<<<<
 * 
 *     def computeBoundingBox(self):
 */
  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    { /* enter inner scope */
      __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 291, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_1 = __pyx_v_k;
      for (__pyx_9genexpr10__pyx_v_i = 0; __pyx_9genexpr10__pyx_v_i < __pyx_t_1; __pyx_9genexpr10__pyx_v_i++) {
        __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toScalar((__pyx_v_cr[__pyx_9genexpr10__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 291, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_5))) __PYX_ERR(16, 291, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      }
    } /* exit inner scope */
    __pyx_r = __pyx_t_2;
    __pyx_t_2 = 0;
    goto __pyx_L0;
  }

  /* "SLEPc/RG.pyx":266
 *         return array_i(n, inside)
 * 
 *     def computeContour(self, n):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the coordinates of several points lying on the contour
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.computeContour", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp1);
  __Pyx_XDECREF(__pyx_v_tmp2);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":293
 *             return [toScalar(cr[i]) for i from 0 <= i <k]
 * 
 *     def computeBoundingBox(self):             # <<<<<<<<<<<<<<
 *         """
 *         Determines the endpoints of a rectangle in the complex plane that
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_35computeBoundingBox(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_34computeBoundingBox[] = "RG.computeBoundingBox(self)\n\n        Determines the endpoints of a rectangle in the complex plane that\n        contains the region.\n\n        Returns\n        -------\n        a: float\n           The left endpoint of the bounding box in the real axis\n        b: float\n           The right endpoint of the bounding box in the real axis\n        c: float\n           The left endpoint of the bounding box in the imaginary axis\n        d: float\n           The right endpoint of the bounding box in the imaginary axis\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_35computeBoundingBox(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("computeBoundingBox (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("computeBoundingBox", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "computeBoundingBox", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_34computeBoundingBox(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_34computeBoundingBox(struct PySlepcRGObject *__pyx_v_self) {
  PetscReal __pyx_v_a;
  PetscReal __pyx_v_b;
  PetscReal __pyx_v_c;
  PetscReal __pyx_v_d;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("computeBoundingBox", 0);

  /* "SLEPc/RG.pyx":309
 *            The right endpoint of the bounding box in the imaginary axis
 *         """
 *         cdef PetscReal a = 0, b = 0, c = 0, d = 0             # <<<<<<<<<<<<<<
 *         CHKERR( RGComputeBoundingBox(self.rg, &a, &b, &c, &d) )
 *         return (toReal(a), toReal(b), toReal(c), toReal(d))
 */
  __pyx_v_a = 0.0;
  __pyx_v_b = 0.0;
  __pyx_v_c = 0.0;
  __pyx_v_d = 0.0;

  /* "SLEPc/RG.pyx":310
 *         """
 *         cdef PetscReal a = 0, b = 0, c = 0, d = 0
 *         CHKERR( RGComputeBoundingBox(self.rg, &a, &b, &c, &d) )             # <<<<<<<<<<<<<<
 *         return (toReal(a), toReal(b), toReal(c), toReal(d))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGComputeBoundingBox(__pyx_v_self->rg, (&__pyx_v_a), (&__pyx_v_b), (&__pyx_v_c), (&__pyx_v_d))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 310, __pyx_L1_error)

  /* "SLEPc/RG.pyx":311
 *         cdef PetscReal a = 0, b = 0, c = 0, d = 0
 *         CHKERR( RGComputeBoundingBox(self.rg, &a, &b, &c, &d) )
 *         return (toReal(a), toReal(b), toReal(c), toReal(d))             # <<<<<<<<<<<<<<
 * 
 *     def canUseConjugates(self, realmats=True):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_a); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_b); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_c); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_d); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(16, 311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_5);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_r = __pyx_t_6;
  __pyx_t_6 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":293
 *             return [toScalar(cr[i]) for i from 0 <= i <k]
 * 
 *     def computeBoundingBox(self):             # <<<<<<<<<<<<<<
 *         """
 *         Determines the endpoints of a rectangle in the complex plane that
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.computeBoundingBox", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":313
 *         return (toReal(a), toReal(b), toReal(c), toReal(d))
 * 
 *     def canUseConjugates(self, realmats=True):             # <<<<<<<<<<<<<<
 *         """
 *         Used in contour integral methods to determine whether half of
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_37canUseConjugates(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_36canUseConjugates[] = "RG.canUseConjugates(self, realmats=True)\n\n        Used in contour integral methods to determine whether half of\n        integration points can be avoided (use their conjugates).\n\n        Parameters\n        ----------\n        realmats: bool, optional\n             True if the problem matrices are real.\n\n        Returns\n        -------\n        useconj: bool\n             Whether it is possible to use conjugates.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_37canUseConjugates(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_realmats = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("canUseConjugates (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_realmats,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_realmats);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "canUseConjugates") < 0)) __PYX_ERR(16, 313, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_realmats = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("canUseConjugates", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 313, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.canUseConjugates", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_36canUseConjugates(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_realmats);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_36canUseConjugates(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_realmats) {
  PetscBool __pyx_v_bval;
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("canUseConjugates", 0);

  /* "SLEPc/RG.pyx":328
 *              Whether it is possible to use conjugates.
 *         """
 *         cdef PetscBool bval = asBool(realmats)             # <<<<<<<<<<<<<<
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( RGCanUseConjugates(self.rg, bval, &tval) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_realmats); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(16, 328, __pyx_L1_error)
  __pyx_v_bval = __pyx_t_1;

  /* "SLEPc/RG.pyx":329
 *         """
 *         cdef PetscBool bval = asBool(realmats)
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( RGCanUseConjugates(self.rg, bval, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/RG.pyx":330
 *         cdef PetscBool bval = asBool(realmats)
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( RGCanUseConjugates(self.rg, bval, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGCanUseConjugates(__pyx_v_self->rg, __pyx_v_bval, (&__pyx_v_tval))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(16, 330, __pyx_L1_error)

  /* "SLEPc/RG.pyx":331
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( RGCanUseConjugates(self.rg, bval, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def computeQuadrature(self, quad, n):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 331, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":313
 *         return (toReal(a), toReal(b), toReal(c), toReal(d))
 * 
 *     def canUseConjugates(self, realmats=True):             # <<<<<<<<<<<<<<
 *         """
 *         Used in contour integral methods to determine whether half of
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.canUseConjugates", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":333
 *         return toBool(tval)
 * 
 *     def computeQuadrature(self, quad, n):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the values of the parameters used in a quadrature rule
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_39computeQuadrature(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_38computeQuadrature[] = "RG.computeQuadrature(self, quad, n)\n\n        Computes the values of the parameters used in a quadrature rule\n        for a contour integral around the boundary of the region.\n\n        Parameters\n        ----------\n        quad: `RG.QuadRule` enumerate\n           The type of quadrature.\n        n: int\n           The number of quadrature points to compute.\n\n        Returns\n        -------\n        z: list of float (real or complex)\n           Quadrature points.\n        zn: list of float (real or complex)\n           Normalized quadrature points.\n        w: list of float (real or complex)\n           Quadrature weights.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_39computeQuadrature(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_quad = 0;
  PyObject *__pyx_v_n = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("computeQuadrature (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_quad,&__pyx_n_s_n,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_quad)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("computeQuadrature", 1, 2, 2, 1); __PYX_ERR(16, 333, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "computeQuadrature") < 0)) __PYX_ERR(16, 333, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_quad = values[0];
    __pyx_v_n = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("computeQuadrature", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 333, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.computeQuadrature", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_38computeQuadrature(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_quad, __pyx_v_n);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_38computeQuadrature(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_quad, PyObject *__pyx_v_n) {
  RGQuadRule __pyx_v_val;
  PetscInt __pyx_v_k;
  CYTHON_UNUSED PetscInt __pyx_v_i;
  PetscScalar *__pyx_v_z;
  PetscScalar *__pyx_v_zn;
  PetscScalar *__pyx_v_w;
  CYTHON_UNUSED PyObject *__pyx_v_tmp1 = 0;
  CYTHON_UNUSED PyObject *__pyx_v_tmp2 = 0;
  CYTHON_UNUSED PyObject *__pyx_v_tmp3 = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  RGQuadRule __pyx_t_1;
  PetscInt __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("computeQuadrature", 0);

  /* "SLEPc/RG.pyx":354
 *            Quadrature weights.
 *         """
 *         cdef SlepcRGQuadRule val = quad             # <<<<<<<<<<<<<<
 *         cdef PetscInt k = asInt(n), i = 0
 *         cdef PetscScalar *z = NULL, *zn = NULL, *w = NULL
 */
  __pyx_t_1 = ((RGQuadRule)__Pyx_PyInt_As_RGQuadRule(__pyx_v_quad)); if (unlikely(PyErr_Occurred())) __PYX_ERR(16, 354, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/RG.pyx":355
 *         """
 *         cdef SlepcRGQuadRule val = quad
 *         cdef PetscInt k = asInt(n), i = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar *z = NULL, *zn = NULL, *w = NULL
 *         cdef tmp1 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&z)
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_n); if (unlikely(__pyx_t_2 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(16, 355, __pyx_L1_error)
  __pyx_v_k = __pyx_t_2;
  __pyx_v_i = 0;

  /* "SLEPc/RG.pyx":356
 *         cdef SlepcRGQuadRule val = quad
 *         cdef PetscInt k = asInt(n), i = 0
 *         cdef PetscScalar *z = NULL, *zn = NULL, *w = NULL             # <<<<<<<<<<<<<<
 *         cdef tmp1 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&z)
 *         cdef tmp2 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&zn)
 */
  __pyx_v_z = NULL;
  __pyx_v_zn = NULL;
  __pyx_v_w = NULL;

  /* "SLEPc/RG.pyx":357
 *         cdef PetscInt k = asInt(n), i = 0
 *         cdef PetscScalar *z = NULL, *zn = NULL, *w = NULL
 *         cdef tmp1 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&z)             # <<<<<<<<<<<<<<
 *         cdef tmp2 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&zn)
 *         cdef tmp3 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&w)
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_k) * (sizeof(PetscScalar))), ((void **)(&__pyx_v_z))); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 357, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp1 = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/RG.pyx":358
 *         cdef PetscScalar *z = NULL, *zn = NULL, *w = NULL
 *         cdef tmp1 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&z)
 *         cdef tmp2 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&zn)             # <<<<<<<<<<<<<<
 *         cdef tmp3 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&w)
 *         CHKERR( RGComputeQuadrature(self.rg, val, k, z, zn, w) )
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_k) * (sizeof(PetscScalar))), ((void **)(&__pyx_v_zn))); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 358, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp2 = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/RG.pyx":359
 *         cdef tmp1 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&z)
 *         cdef tmp2 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&zn)
 *         cdef tmp3 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&w)             # <<<<<<<<<<<<<<
 *         CHKERR( RGComputeQuadrature(self.rg, val, k, z, zn, w) )
 *         return (array_s(k, z), array_s(k, zn), array_s(k, w))
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_k) * (sizeof(PetscScalar))), ((void **)(&__pyx_v_w))); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 359, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp3 = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/RG.pyx":360
 *         cdef tmp2 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&zn)
 *         cdef tmp3 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&w)
 *         CHKERR( RGComputeQuadrature(self.rg, val, k, z, zn, w) )             # <<<<<<<<<<<<<<
 *         return (array_s(k, z), array_s(k, zn), array_s(k, w))
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGComputeQuadrature(__pyx_v_self->rg, __pyx_v_val, __pyx_v_k, __pyx_v_z, __pyx_v_zn, __pyx_v_w)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(16, 360, __pyx_L1_error)

  /* "SLEPc/RG.pyx":361
 *         cdef tmp3 = allocate(<size_t>k*sizeof(PetscScalar),<void**>&w)
 *         CHKERR( RGComputeQuadrature(self.rg, val, k, z, zn, w) )
 *         return (array_s(k, z), array_s(k, zn), array_s(k, w))             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_s(__pyx_v_k, __pyx_v_z)); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_s(__pyx_v_k, __pyx_v_zn)); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_s(__pyx_v_k, __pyx_v_w)); if (unlikely(!__pyx_t_6)) __PYX_ERR(16, 361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(16, 361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_6);
  __pyx_t_3 = 0;
  __pyx_t_5 = 0;
  __pyx_t_6 = 0;
  __pyx_r = __pyx_t_7;
  __pyx_t_7 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":333
 *         return toBool(tval)
 * 
 *     def computeQuadrature(self, quad, n):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the values of the parameters used in a quadrature rule
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.computeQuadrature", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp1);
  __Pyx_XDECREF(__pyx_v_tmp2);
  __Pyx_XDECREF(__pyx_v_tmp3);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":365
 *     #
 * 
 *     def setEllipseParameters(self, center, radius, vscale=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the parameters defining the ellipse region.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_41setEllipseParameters(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_40setEllipseParameters[] = "RG.setEllipseParameters(self, center, radius, vscale=None)\n\n        Sets the parameters defining the ellipse region.\n\n        Parameters\n        ----------\n        center: float (real or complex)\n              The center.\n        radius: float\n              The radius.\n        vscale: float, optional\n              The vertical scale.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_41setEllipseParameters(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_center = 0;
  PyObject *__pyx_v_radius = 0;
  PyObject *__pyx_v_vscale = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setEllipseParameters (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_center,&__pyx_n_s_radius,&__pyx_n_s_vscale,0};
    PyObject* values[3] = {0,0,0};
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_center)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_radius)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setEllipseParameters", 0, 2, 3, 1); __PYX_ERR(16, 365, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_vscale);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setEllipseParameters") < 0)) __PYX_ERR(16, 365, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_center = values[0];
    __pyx_v_radius = values[1];
    __pyx_v_vscale = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setEllipseParameters", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 365, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setEllipseParameters", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_40setEllipseParameters(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_center, __pyx_v_radius, __pyx_v_vscale);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_40setEllipseParameters(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_center, PyObject *__pyx_v_radius, PyObject *__pyx_v_vscale) {
  PetscScalar __pyx_v_sval;
  PetscReal __pyx_v_val1;
  PetscReal __pyx_v_val2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  PetscReal __pyx_t_2;
  int __pyx_t_3;
  int __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setEllipseParameters", 0);

  /* "SLEPc/RG.pyx":378
 *               The vertical scale.
 *         """
 *         cdef PetscScalar sval = asScalar(center)             # <<<<<<<<<<<<<<
 *         cdef PetscReal val1 = asReal(radius)
 *         cdef PetscReal val2 = 1.0
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_center); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(16, 378, __pyx_L1_error)
  __pyx_v_sval = __pyx_t_1;

  /* "SLEPc/RG.pyx":379
 *         """
 *         cdef PetscScalar sval = asScalar(center)
 *         cdef PetscReal val1 = asReal(radius)             # <<<<<<<<<<<<<<
 *         cdef PetscReal val2 = 1.0
 *         if vscale is not None: val2 = asReal(vscale)
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_radius); if (unlikely(__pyx_t_2 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(16, 379, __pyx_L1_error)
  __pyx_v_val1 = __pyx_t_2;

  /* "SLEPc/RG.pyx":380
 *         cdef PetscScalar sval = asScalar(center)
 *         cdef PetscReal val1 = asReal(radius)
 *         cdef PetscReal val2 = 1.0             # <<<<<<<<<<<<<<
 *         if vscale is not None: val2 = asReal(vscale)
 *         CHKERR( RGEllipseSetParameters(self.rg, sval, val1, val2) )
 */
  __pyx_v_val2 = 1.0;

  /* "SLEPc/RG.pyx":381
 *         cdef PetscReal val1 = asReal(radius)
 *         cdef PetscReal val2 = 1.0
 *         if vscale is not None: val2 = asReal(vscale)             # <<<<<<<<<<<<<<
 *         CHKERR( RGEllipseSetParameters(self.rg, sval, val1, val2) )
 * 
 */
  __pyx_t_3 = (__pyx_v_vscale != Py_None);
  __pyx_t_4 = (__pyx_t_3 != 0);
  if (__pyx_t_4) {
    __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_vscale); if (unlikely(__pyx_t_2 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(16, 381, __pyx_L1_error)
    __pyx_v_val2 = __pyx_t_2;
  }

  /* "SLEPc/RG.pyx":382
 *         cdef PetscReal val2 = 1.0
 *         if vscale is not None: val2 = asReal(vscale)
 *         CHKERR( RGEllipseSetParameters(self.rg, sval, val1, val2) )             # <<<<<<<<<<<<<<
 * 
 *     def getEllipseParameters(self):
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGEllipseSetParameters(__pyx_v_self->rg, __pyx_v_sval, __pyx_v_val1, __pyx_v_val2)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(16, 382, __pyx_L1_error)

  /* "SLEPc/RG.pyx":365
 *     #
 * 
 *     def setEllipseParameters(self, center, radius, vscale=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the parameters defining the ellipse region.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setEllipseParameters", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":384
 *         CHKERR( RGEllipseSetParameters(self.rg, sval, val1, val2) )
 * 
 *     def getEllipseParameters(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the parameters that define the ellipse region.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_43getEllipseParameters(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_42getEllipseParameters[] = "RG.getEllipseParameters(self)\n\n        Gets the parameters that define the ellipse region.\n\n        Returns\n        -------\n        center: float (real or complex)\n              The center.\n        radius: float\n              The radius.\n        vscale: float\n              The vertical scale.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_43getEllipseParameters(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getEllipseParameters (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getEllipseParameters", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getEllipseParameters", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_42getEllipseParameters(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_42getEllipseParameters(struct PySlepcRGObject *__pyx_v_self) {
  PetscScalar __pyx_v_sval;
  PetscReal __pyx_v_val1;
  PetscReal __pyx_v_val2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getEllipseParameters", 0);

  /* "SLEPc/RG.pyx":397
 *               The vertical scale.
 *         """
 *         cdef PetscScalar sval = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal val1 = 0
 *         cdef PetscReal val2 = 0
 */
  __pyx_v_sval = 0.0;

  /* "SLEPc/RG.pyx":398
 *         """
 *         cdef PetscScalar sval = 0
 *         cdef PetscReal val1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal val2 = 0
 *         CHKERR( RGEllipseGetParameters(self.rg, &sval, &val1, &val2) )
 */
  __pyx_v_val1 = 0.0;

  /* "SLEPc/RG.pyx":399
 *         cdef PetscScalar sval = 0
 *         cdef PetscReal val1 = 0
 *         cdef PetscReal val2 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( RGEllipseGetParameters(self.rg, &sval, &val1, &val2) )
 *         return (toScalar(sval), toReal(val1), toReal(val2))
 */
  __pyx_v_val2 = 0.0;

  /* "SLEPc/RG.pyx":400
 *         cdef PetscReal val1 = 0
 *         cdef PetscReal val2 = 0
 *         CHKERR( RGEllipseGetParameters(self.rg, &sval, &val1, &val2) )             # <<<<<<<<<<<<<<
 *         return (toScalar(sval), toReal(val1), toReal(val2))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGEllipseGetParameters(__pyx_v_self->rg, (&__pyx_v_sval), (&__pyx_v_val1), (&__pyx_v_val2))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 400, __pyx_L1_error)

  /* "SLEPc/RG.pyx":401
 *         cdef PetscReal val2 = 0
 *         CHKERR( RGEllipseGetParameters(self.rg, &sval, &val1, &val2) )
 *         return (toScalar(sval), toReal(val1), toReal(val2))             # <<<<<<<<<<<<<<
 * 
 *     def setIntervalEndpoints(self, a, b, c, d):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_sval); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 401, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val1); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 401, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val2); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 401, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 401, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":384
 *         CHKERR( RGEllipseSetParameters(self.rg, sval, val1, val2) )
 * 
 *     def getEllipseParameters(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the parameters that define the ellipse region.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.getEllipseParameters", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":403
 *         return (toScalar(sval), toReal(val1), toReal(val2))
 * 
 *     def setIntervalEndpoints(self, a, b, c, d):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the parameters defining the interval region.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_45setIntervalEndpoints(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_44setIntervalEndpoints[] = "RG.setIntervalEndpoints(self, a, b, c, d)\n\n        Sets the parameters defining the interval region.\n\n        Parameters\n        ----------\n        a: float\n              The left endpoint in the real axis.\n        b: float\n              The right endpoint in the real axis.\n        c: float\n              The upper endpoint in the imaginary axis.\n        d: float\n              The lower endpoint in the imaginary axis.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_45setIntervalEndpoints(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_a = 0;
  PyObject *__pyx_v_b = 0;
  PyObject *__pyx_v_c = 0;
  PyObject *__pyx_v_d = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setIntervalEndpoints (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_a,&__pyx_n_s_b,&__pyx_n_s_c,&__pyx_n_s_d,0};
    PyObject* values[4] = {0,0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_a)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_b)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setIntervalEndpoints", 1, 4, 4, 1); __PYX_ERR(16, 403, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setIntervalEndpoints", 1, 4, 4, 2); __PYX_ERR(16, 403, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_d)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setIntervalEndpoints", 1, 4, 4, 3); __PYX_ERR(16, 403, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setIntervalEndpoints") < 0)) __PYX_ERR(16, 403, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
    }
    __pyx_v_a = values[0];
    __pyx_v_b = values[1];
    __pyx_v_c = values[2];
    __pyx_v_d = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setIntervalEndpoints", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 403, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setIntervalEndpoints", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_44setIntervalEndpoints(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_a, __pyx_v_b, __pyx_v_c, __pyx_v_d);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_44setIntervalEndpoints(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) {
  PetscReal __pyx_v_va;
  PetscReal __pyx_v_vb;
  PetscReal __pyx_v_vc;
  PetscReal __pyx_v_vd;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setIntervalEndpoints", 0);

  /* "SLEPc/RG.pyx":418
 *               The lower endpoint in the imaginary axis.
 *         """
 *         cdef PetscReal va = asReal(a)             # <<<<<<<<<<<<<<
 *         cdef PetscReal vb = asReal(b)
 *         cdef PetscReal vc = asReal(c)
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_a); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(16, 418, __pyx_L1_error)
  __pyx_v_va = __pyx_t_1;

  /* "SLEPc/RG.pyx":419
 *         """
 *         cdef PetscReal va = asReal(a)
 *         cdef PetscReal vb = asReal(b)             # <<<<<<<<<<<<<<
 *         cdef PetscReal vc = asReal(c)
 *         cdef PetscReal vd = asReal(d)
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_b); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(16, 419, __pyx_L1_error)
  __pyx_v_vb = __pyx_t_1;

  /* "SLEPc/RG.pyx":420
 *         cdef PetscReal va = asReal(a)
 *         cdef PetscReal vb = asReal(b)
 *         cdef PetscReal vc = asReal(c)             # <<<<<<<<<<<<<<
 *         cdef PetscReal vd = asReal(d)
 *         CHKERR( RGIntervalSetEndpoints(self.rg, va, vb, vc, vd) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_c); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(16, 420, __pyx_L1_error)
  __pyx_v_vc = __pyx_t_1;

  /* "SLEPc/RG.pyx":421
 *         cdef PetscReal vb = asReal(b)
 *         cdef PetscReal vc = asReal(c)
 *         cdef PetscReal vd = asReal(d)             # <<<<<<<<<<<<<<
 *         CHKERR( RGIntervalSetEndpoints(self.rg, va, vb, vc, vd) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_d); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(16, 421, __pyx_L1_error)
  __pyx_v_vd = __pyx_t_1;

  /* "SLEPc/RG.pyx":422
 *         cdef PetscReal vc = asReal(c)
 *         cdef PetscReal vd = asReal(d)
 *         CHKERR( RGIntervalSetEndpoints(self.rg, va, vb, vc, vd) )             # <<<<<<<<<<<<<<
 * 
 *     def getIntervalEndpoints(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGIntervalSetEndpoints(__pyx_v_self->rg, __pyx_v_va, __pyx_v_vb, __pyx_v_vc, __pyx_v_vd)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(16, 422, __pyx_L1_error)

  /* "SLEPc/RG.pyx":403
 *         return (toScalar(sval), toReal(val1), toReal(val2))
 * 
 *     def setIntervalEndpoints(self, a, b, c, d):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the parameters defining the interval region.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setIntervalEndpoints", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":424
 *         CHKERR( RGIntervalSetEndpoints(self.rg, va, vb, vc, vd) )
 * 
 *     def getIntervalEndpoints(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the parameters that define the interval region.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_47getIntervalEndpoints(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_46getIntervalEndpoints[] = "RG.getIntervalEndpoints(self)\n\n        Gets the parameters that define the interval region.\n\n        Returns\n        -------\n        a: float\n              The left endpoint in the real axis.\n        b: float\n              The right endpoint in the real axis.\n        c: float\n              The upper endpoint in the imaginary axis.\n        d: float\n              The lower endpoint in the imaginary axis.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_47getIntervalEndpoints(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getIntervalEndpoints (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getIntervalEndpoints", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getIntervalEndpoints", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_46getIntervalEndpoints(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_46getIntervalEndpoints(struct PySlepcRGObject *__pyx_v_self) {
  PetscReal __pyx_v_va;
  PetscReal __pyx_v_vb;
  PetscReal __pyx_v_vc;
  PetscReal __pyx_v_vd;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getIntervalEndpoints", 0);

  /* "SLEPc/RG.pyx":439
 *               The lower endpoint in the imaginary axis.
 *         """
 *         cdef PetscReal va = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal vb = 0
 *         cdef PetscReal vc = 0
 */
  __pyx_v_va = 0.0;

  /* "SLEPc/RG.pyx":440
 *         """
 *         cdef PetscReal va = 0
 *         cdef PetscReal vb = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal vc = 0
 *         cdef PetscReal vd = 0
 */
  __pyx_v_vb = 0.0;

  /* "SLEPc/RG.pyx":441
 *         cdef PetscReal va = 0
 *         cdef PetscReal vb = 0
 *         cdef PetscReal vc = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal vd = 0
 *         CHKERR( RGIntervalGetEndpoints(self.rg, &va, &vb, &vc, &vd) )
 */
  __pyx_v_vc = 0.0;

  /* "SLEPc/RG.pyx":442
 *         cdef PetscReal vb = 0
 *         cdef PetscReal vc = 0
 *         cdef PetscReal vd = 0             # <<<<<<<<<<<<<<
 *         CHKERR( RGIntervalGetEndpoints(self.rg, &va, &vb, &vc, &vd) )
 *         return (toReal(va), toReal(vb), toReal(vc), toReal(vd))
 */
  __pyx_v_vd = 0.0;

  /* "SLEPc/RG.pyx":443
 *         cdef PetscReal vc = 0
 *         cdef PetscReal vd = 0
 *         CHKERR( RGIntervalGetEndpoints(self.rg, &va, &vb, &vc, &vd) )             # <<<<<<<<<<<<<<
 *         return (toReal(va), toReal(vb), toReal(vc), toReal(vd))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGIntervalGetEndpoints(__pyx_v_self->rg, (&__pyx_v_va), (&__pyx_v_vb), (&__pyx_v_vc), (&__pyx_v_vd))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 443, __pyx_L1_error)

  /* "SLEPc/RG.pyx":444
 *         cdef PetscReal vd = 0
 *         CHKERR( RGIntervalGetEndpoints(self.rg, &va, &vb, &vc, &vd) )
 *         return (toReal(va), toReal(vb), toReal(vc), toReal(vd))             # <<<<<<<<<<<<<<
 * 
 *     def setPolygonVertices(self, v):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_va); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_vb); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_vc); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_vd); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(16, 444, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_5);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_r = __pyx_t_6;
  __pyx_t_6 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":424
 *         CHKERR( RGIntervalSetEndpoints(self.rg, va, vb, vc, vd) )
 * 
 *     def getIntervalEndpoints(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the parameters that define the interval region.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.getIntervalEndpoints", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":446
 *         return (toReal(va), toReal(vb), toReal(vc), toReal(vd))
 * 
 *     def setPolygonVertices(self, v):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the vertices that define the polygon region.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_49setPolygonVertices(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_48setPolygonVertices[] = "RG.setPolygonVertices(self, v)\n\n        Sets the vertices that define the polygon region.\n\n        Parameters\n        ----------\n        v: list of float (complex)\n           The vertices.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_49setPolygonVertices(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_v = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setPolygonVertices (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_v,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_v)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setPolygonVertices") < 0)) __PYX_ERR(16, 446, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_v = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setPolygonVertices", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 446, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setPolygonVertices", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_48setPolygonVertices(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_v);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_48setPolygonVertices(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_v) {
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_n;
  PetscScalar *__pyx_v_vr;
  PetscScalar *__pyx_v_vi;
  CYTHON_UNUSED PyObject *__pyx_v_tmp1 = 0;
  CYTHON_UNUSED PyObject *__pyx_v_tmp2 = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Py_ssize_t __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  PetscReal __pyx_t_6;
  PetscScalar __pyx_t_7;
  int __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setPolygonVertices", 0);

  /* "SLEPc/RG.pyx":455
 *            The vertices.
 *         """
 *         cdef Py_ssize_t i = 0, n = len(v)             # <<<<<<<<<<<<<<
 *         cdef PetscScalar *vr = NULL, *vi = NULL
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&vr)
 */
  __pyx_v_i = 0;
  __pyx_t_1 = PyObject_Length(__pyx_v_v); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(16, 455, __pyx_L1_error)
  __pyx_v_n = __pyx_t_1;

  /* "SLEPc/RG.pyx":456
 *         """
 *         cdef Py_ssize_t i = 0, n = len(v)
 *         cdef PetscScalar *vr = NULL, *vi = NULL             # <<<<<<<<<<<<<<
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&vr)
 *         cdef tmp2
 */
  __pyx_v_vr = NULL;
  __pyx_v_vi = NULL;

  /* "SLEPc/RG.pyx":457
 *         cdef Py_ssize_t i = 0, n = len(v)
 *         cdef PetscScalar *vr = NULL, *vi = NULL
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&vr)             # <<<<<<<<<<<<<<
 *         cdef tmp2
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_n) * (sizeof(PetscScalar))), ((void **)(&__pyx_v_vr))); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 457, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_tmp1 = __pyx_t_2;
  __pyx_t_2 = 0;

  /* "SLEPc/RG.pyx":459
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&vr)
 *         cdef tmp2
 *         if sizeof(PetscScalar) == sizeof(PetscReal):             # <<<<<<<<<<<<<<
 *             tmp2 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&vi)
 *             for i in range(n):
 */
  __pyx_t_3 = (((sizeof(PetscScalar)) == (sizeof(PetscReal))) != 0);
  if (__pyx_t_3) {

    /* "SLEPc/RG.pyx":460
 *         cdef tmp2
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 *             tmp2 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&vi)             # <<<<<<<<<<<<<<
 *             for i in range(n):
 *                 vr[i] = asComplexReal(v[i])
 */
    __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_n) * (sizeof(PetscScalar))), ((void **)(&__pyx_v_vi))); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 460, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_v_tmp2 = __pyx_t_2;
    __pyx_t_2 = 0;

    /* "SLEPc/RG.pyx":461
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 *             tmp2 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&vi)
 *             for i in range(n):             # <<<<<<<<<<<<<<
 *                 vr[i] = asComplexReal(v[i])
 *                 vi[i] = asComplexImag(v[i])
 */
    __pyx_t_1 = __pyx_v_n;
    __pyx_t_4 = __pyx_t_1;
    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
      __pyx_v_i = __pyx_t_5;

      /* "SLEPc/RG.pyx":462
 *             tmp2 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&vi)
 *             for i in range(n):
 *                 vr[i] = asComplexReal(v[i])             # <<<<<<<<<<<<<<
 *                 vi[i] = asComplexImag(v[i])
 *         else:
 */
      __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_v, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 462, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_asComplexReal(__pyx_t_2); if (unlikely(__pyx_t_6 == ((PetscReal)((PetscReal)(-1.0))) && PyErr_Occurred())) __PYX_ERR(16, 462, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      (__pyx_v_vr[__pyx_v_i]) = __pyx_t_6;

      /* "SLEPc/RG.pyx":463
 *             for i in range(n):
 *                 vr[i] = asComplexReal(v[i])
 *                 vi[i] = asComplexImag(v[i])             # <<<<<<<<<<<<<<
 *         else:
 *             for i in range(n): vr[i] = asScalar(v[i])
 */
      __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_v, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 463, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_asComplexImag(__pyx_t_2); if (unlikely(__pyx_t_6 == ((PetscReal)((PetscReal)(-1.0))) && PyErr_Occurred())) __PYX_ERR(16, 463, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      (__pyx_v_vi[__pyx_v_i]) = __pyx_t_6;
    }

    /* "SLEPc/RG.pyx":459
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&vr)
 *         cdef tmp2
 *         if sizeof(PetscScalar) == sizeof(PetscReal):             # <<<<<<<<<<<<<<
 *             tmp2 = allocate(<size_t>n*sizeof(PetscScalar),<void**>&vi)
 *             for i in range(n):
 */
    goto __pyx_L3;
  }

  /* "SLEPc/RG.pyx":465
 *                 vi[i] = asComplexImag(v[i])
 *         else:
 *             for i in range(n): vr[i] = asScalar(v[i])             # <<<<<<<<<<<<<<
 *         CHKERR( RGPolygonSetVertices(self.rg, <PetscInt>n, vr, vi) )
 * 
 */
  /*else*/ {
    __pyx_t_1 = __pyx_v_n;
    __pyx_t_4 = __pyx_t_1;
    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
      __pyx_v_i = __pyx_t_5;
      __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_v, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 465, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_t_2); if (unlikely(__pyx_t_7 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(16, 465, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      (__pyx_v_vr[__pyx_v_i]) = __pyx_t_7;
    }
  }
  __pyx_L3:;

  /* "SLEPc/RG.pyx":466
 *         else:
 *             for i in range(n): vr[i] = asScalar(v[i])
 *         CHKERR( RGPolygonSetVertices(self.rg, <PetscInt>n, vr, vi) )             # <<<<<<<<<<<<<<
 * 
 *     def getPolygonVertices(self):
 */
  __pyx_t_8 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGPolygonSetVertices(__pyx_v_self->rg, ((PetscInt)__pyx_v_n), __pyx_v_vr, __pyx_v_vi)); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(16, 466, __pyx_L1_error)

  /* "SLEPc/RG.pyx":446
 *         return (toReal(va), toReal(vb), toReal(vc), toReal(vd))
 * 
 *     def setPolygonVertices(self, v):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the vertices that define the polygon region.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setPolygonVertices", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp1);
  __Pyx_XDECREF(__pyx_v_tmp2);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":468
 *         CHKERR( RGPolygonSetVertices(self.rg, <PetscInt>n, vr, vi) )
 * 
 *     def getPolygonVertices(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the parameters that define the interval region.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_51getPolygonVertices(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_50getPolygonVertices[] = "RG.getPolygonVertices(self)\n\n        Gets the parameters that define the interval region.\n\n        Returns\n        -------\n        v: list of float (complex)\n           The vertices.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_51getPolygonVertices(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getPolygonVertices (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getPolygonVertices", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getPolygonVertices", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_50getPolygonVertices(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_50getPolygonVertices(struct PySlepcRGObject *__pyx_v_self) {
  PetscInt __pyx_v_n;
  PetscScalar *__pyx_v_vr;
  PetscScalar *__pyx_v_vi;
  PyObject *__pyx_v_v = NULL;
  long __pyx_9genexpr11__pyx_v_i;
  long __pyx_9genexpr12__pyx_v_i;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PetscInt __pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getPolygonVertices", 0);

  /* "SLEPc/RG.pyx":477
 *            The vertices.
 *         """
 *         cdef PetscInt n = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar *vr = NULL, *vi = NULL
 *         CHKERR( RGPolygonGetVertices(self.rg, &n, &vr, &vi) )
 */
  __pyx_v_n = 0;

  /* "SLEPc/RG.pyx":478
 *         """
 *         cdef PetscInt n = 0
 *         cdef PetscScalar *vr = NULL, *vi = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( RGPolygonGetVertices(self.rg, &n, &vr, &vi) )
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 */
  __pyx_v_vr = NULL;
  __pyx_v_vi = NULL;

  /* "SLEPc/RG.pyx":479
 *         cdef PetscInt n = 0
 *         cdef PetscScalar *vr = NULL, *vi = NULL
 *         CHKERR( RGPolygonGetVertices(self.rg, &n, &vr, &vi) )             # <<<<<<<<<<<<<<
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 *             v = [toComplex(vr[i],vi[i]) for i from 0 <= i <n]
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGPolygonGetVertices(__pyx_v_self->rg, (&__pyx_v_n), (&__pyx_v_vr), (&__pyx_v_vi))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 479, __pyx_L1_error)

  /* "SLEPc/RG.pyx":480
 *         cdef PetscScalar *vr = NULL, *vi = NULL
 *         CHKERR( RGPolygonGetVertices(self.rg, &n, &vr, &vi) )
 *         if sizeof(PetscScalar) == sizeof(PetscReal):             # <<<<<<<<<<<<<<
 *             v = [toComplex(vr[i],vi[i]) for i from 0 <= i <n]
 *             CHKERR( PetscFree(vi) )
 */
  __pyx_t_2 = (((sizeof(PetscScalar)) == (sizeof(PetscReal))) != 0);
  if (__pyx_t_2) {

    /* "SLEPc/RG.pyx":481
 *         CHKERR( RGPolygonGetVertices(self.rg, &n, &vr, &vi) )
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 *             v = [toComplex(vr[i],vi[i]) for i from 0 <= i <n]             # <<<<<<<<<<<<<<
 *             CHKERR( PetscFree(vi) )
 *         else:
 */
    { /* enter inner scope */
      __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 481, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __pyx_v_n;
      for (__pyx_9genexpr11__pyx_v_i = 0; __pyx_9genexpr11__pyx_v_i < __pyx_t_4; __pyx_9genexpr11__pyx_v_i++) {
        __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toComplex((__pyx_v_vr[__pyx_9genexpr11__pyx_v_i]), (__pyx_v_vi[__pyx_9genexpr11__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 481, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_5))) __PYX_ERR(16, 481, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      }
    } /* exit inner scope */
    __pyx_v_v = ((PyObject*)__pyx_t_3);
    __pyx_t_3 = 0;

    /* "SLEPc/RG.pyx":482
 *         if sizeof(PetscScalar) == sizeof(PetscReal):
 *             v = [toComplex(vr[i],vi[i]) for i from 0 <= i <n]
 *             CHKERR( PetscFree(vi) )             # <<<<<<<<<<<<<<
 *         else:
 *             v = [toScalar(vr[i]) for i from 0 <= i <n]
 */
    __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_vi)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 482, __pyx_L1_error)

    /* "SLEPc/RG.pyx":480
 *         cdef PetscScalar *vr = NULL, *vi = NULL
 *         CHKERR( RGPolygonGetVertices(self.rg, &n, &vr, &vi) )
 *         if sizeof(PetscScalar) == sizeof(PetscReal):             # <<<<<<<<<<<<<<
 *             v = [toComplex(vr[i],vi[i]) for i from 0 <= i <n]
 *             CHKERR( PetscFree(vi) )
 */
    goto __pyx_L3;
  }

  /* "SLEPc/RG.pyx":484
 *             CHKERR( PetscFree(vi) )
 *         else:
 *             v = [toScalar(vr[i]) for i from 0 <= i <n]             # <<<<<<<<<<<<<<
 *         CHKERR( PetscFree(vr) )
 *         return v
 */
  /*else*/ {
    { /* enter inner scope */
      __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 484, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __pyx_v_n;
      for (__pyx_9genexpr12__pyx_v_i = 0; __pyx_9genexpr12__pyx_v_i < __pyx_t_4; __pyx_9genexpr12__pyx_v_i++) {
        __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toScalar((__pyx_v_vr[__pyx_9genexpr12__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 484, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_5))) __PYX_ERR(16, 484, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      }
    } /* exit inner scope */
    __pyx_v_v = ((PyObject*)__pyx_t_3);
    __pyx_t_3 = 0;
  }
  __pyx_L3:;

  /* "SLEPc/RG.pyx":485
 *         else:
 *             v = [toScalar(vr[i]) for i from 0 <= i <n]
 *         CHKERR( PetscFree(vr) )             # <<<<<<<<<<<<<<
 *         return v
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_vr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 485, __pyx_L1_error)

  /* "SLEPc/RG.pyx":486
 *             v = [toScalar(vr[i]) for i from 0 <= i <n]
 *         CHKERR( PetscFree(vr) )
 *         return v             # <<<<<<<<<<<<<<
 * 
 *     def setRingParameters(self, center, radius, vscale, start_ang, end_ang, width):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_v);
  __pyx_r = __pyx_v_v;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":468
 *         CHKERR( RGPolygonSetVertices(self.rg, <PetscInt>n, vr, vi) )
 * 
 *     def getPolygonVertices(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the parameters that define the interval region.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.getPolygonVertices", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_v);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":488
 *         return v
 * 
 *     def setRingParameters(self, center, radius, vscale, start_ang, end_ang, width):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the parameters defining the ring region.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_53setRingParameters(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_52setRingParameters[] = "RG.setRingParameters(self, center, radius, vscale, start_ang, end_ang, width)\n\n        Sets the parameters defining the ring region.\n\n        Parameters\n        ----------\n        center: float (real or complex)\n              The center.\n        radius: float\n              The radius.\n        vscale: float\n              The vertical scale.\n        start_ang: float\n              The right-hand side angle.\n        end_ang: float\n              The left-hand side angle.\n        width: float\n              The width of the ring.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_53setRingParameters(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_center = 0;
  PyObject *__pyx_v_radius = 0;
  PyObject *__pyx_v_vscale = 0;
  PyObject *__pyx_v_start_ang = 0;
  PyObject *__pyx_v_end_ang = 0;
  PyObject *__pyx_v_width = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRingParameters (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_center,&__pyx_n_s_radius,&__pyx_n_s_vscale,&__pyx_n_s_start_ang,&__pyx_n_s_end_ang,&__pyx_n_s_width,0};
    PyObject* values[6] = {0,0,0,0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_center)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_radius)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setRingParameters", 1, 6, 6, 1); __PYX_ERR(16, 488, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_vscale)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setRingParameters", 1, 6, 6, 2); __PYX_ERR(16, 488, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start_ang)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setRingParameters", 1, 6, 6, 3); __PYX_ERR(16, 488, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_end_ang)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setRingParameters", 1, 6, 6, 4); __PYX_ERR(16, 488, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_width)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setRingParameters", 1, 6, 6, 5); __PYX_ERR(16, 488, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRingParameters") < 0)) __PYX_ERR(16, 488, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 6) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
      values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
      values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
    }
    __pyx_v_center = values[0];
    __pyx_v_radius = values[1];
    __pyx_v_vscale = values[2];
    __pyx_v_start_ang = values[3];
    __pyx_v_end_ang = values[4];
    __pyx_v_width = values[5];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRingParameters", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 488, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setRingParameters", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_52setRingParameters(((struct PySlepcRGObject *)__pyx_v_self), __pyx_v_center, __pyx_v_radius, __pyx_v_vscale, __pyx_v_start_ang, __pyx_v_end_ang, __pyx_v_width);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_52setRingParameters(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_center, PyObject *__pyx_v_radius, PyObject *__pyx_v_vscale, PyObject *__pyx_v_start_ang, PyObject *__pyx_v_end_ang, PyObject *__pyx_v_width) {
  PetscScalar __pyx_v_sval;
  PetscReal __pyx_v_val1;
  PetscReal __pyx_v_val2;
  PetscReal __pyx_v_val3;
  PetscReal __pyx_v_val4;
  PetscReal __pyx_v_val5;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  PetscReal __pyx_t_2;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRingParameters", 0);

  /* "SLEPc/RG.pyx":507
 *               The width of the ring.
 *         """
 *         cdef PetscScalar sval = asScalar(center)             # <<<<<<<<<<<<<<
 *         cdef PetscReal val1 = asReal(radius)
 *         cdef PetscReal val2 = asReal(vscale)
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_center); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(16, 507, __pyx_L1_error)
  __pyx_v_sval = __pyx_t_1;

  /* "SLEPc/RG.pyx":508
 *         """
 *         cdef PetscScalar sval = asScalar(center)
 *         cdef PetscReal val1 = asReal(radius)             # <<<<<<<<<<<<<<
 *         cdef PetscReal val2 = asReal(vscale)
 *         cdef PetscReal val3 = asReal(start_ang)
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_radius); if (unlikely(__pyx_t_2 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(16, 508, __pyx_L1_error)
  __pyx_v_val1 = __pyx_t_2;

  /* "SLEPc/RG.pyx":509
 *         cdef PetscScalar sval = asScalar(center)
 *         cdef PetscReal val1 = asReal(radius)
 *         cdef PetscReal val2 = asReal(vscale)             # <<<<<<<<<<<<<<
 *         cdef PetscReal val3 = asReal(start_ang)
 *         cdef PetscReal val4 = asReal(end_ang)
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_vscale); if (unlikely(__pyx_t_2 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(16, 509, __pyx_L1_error)
  __pyx_v_val2 = __pyx_t_2;

  /* "SLEPc/RG.pyx":510
 *         cdef PetscReal val1 = asReal(radius)
 *         cdef PetscReal val2 = asReal(vscale)
 *         cdef PetscReal val3 = asReal(start_ang)             # <<<<<<<<<<<<<<
 *         cdef PetscReal val4 = asReal(end_ang)
 *         cdef PetscReal val5 = asReal(width)
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_start_ang); if (unlikely(__pyx_t_2 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(16, 510, __pyx_L1_error)
  __pyx_v_val3 = __pyx_t_2;

  /* "SLEPc/RG.pyx":511
 *         cdef PetscReal val2 = asReal(vscale)
 *         cdef PetscReal val3 = asReal(start_ang)
 *         cdef PetscReal val4 = asReal(end_ang)             # <<<<<<<<<<<<<<
 *         cdef PetscReal val5 = asReal(width)
 *         CHKERR( RGRingSetParameters(self.rg, sval, val1, val2, val3, val4, val5) )
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_end_ang); if (unlikely(__pyx_t_2 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(16, 511, __pyx_L1_error)
  __pyx_v_val4 = __pyx_t_2;

  /* "SLEPc/RG.pyx":512
 *         cdef PetscReal val3 = asReal(start_ang)
 *         cdef PetscReal val4 = asReal(end_ang)
 *         cdef PetscReal val5 = asReal(width)             # <<<<<<<<<<<<<<
 *         CHKERR( RGRingSetParameters(self.rg, sval, val1, val2, val3, val4, val5) )
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_width); if (unlikely(__pyx_t_2 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(16, 512, __pyx_L1_error)
  __pyx_v_val5 = __pyx_t_2;

  /* "SLEPc/RG.pyx":513
 *         cdef PetscReal val4 = asReal(end_ang)
 *         cdef PetscReal val5 = asReal(width)
 *         CHKERR( RGRingSetParameters(self.rg, sval, val1, val2, val3, val4, val5) )             # <<<<<<<<<<<<<<
 * 
 *     def getRingParameters(self):
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGRingSetParameters(__pyx_v_self->rg, __pyx_v_sval, __pyx_v_val1, __pyx_v_val2, __pyx_v_val3, __pyx_v_val4, __pyx_v_val5)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(16, 513, __pyx_L1_error)

  /* "SLEPc/RG.pyx":488
 *         return v
 * 
 *     def setRingParameters(self, center, radius, vscale, start_ang, end_ang, width):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the parameters defining the ring region.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.setRingParameters", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":515
 *         CHKERR( RGRingSetParameters(self.rg, sval, val1, val2, val3, val4, val5) )
 * 
 *     def getRingParameters(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the parameters that define the ring region.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_55getRingParameters(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2RG_54getRingParameters[] = "RG.getRingParameters(self)\n\n        Gets the parameters that define the ring region.\n\n        Returns\n        -------\n        center: float (real or complex)\n              The center.\n        radius: float\n              The radius.\n        vscale: float\n              The vertical scale.\n        start_ang: float\n              The right-hand side angle.\n        end_ang: float\n              The left-hand side angle.\n        width: float\n              The width of the ring.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_55getRingParameters(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRingParameters (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRingParameters", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRingParameters", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_54getRingParameters(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_54getRingParameters(struct PySlepcRGObject *__pyx_v_self) {
  PetscScalar __pyx_v_sval;
  PetscReal __pyx_v_val1;
  PetscReal __pyx_v_val2;
  PetscReal __pyx_v_val3;
  PetscReal __pyx_v_val4;
  PetscReal __pyx_v_val5;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRingParameters", 0);

  /* "SLEPc/RG.pyx":534
 *               The width of the ring.
 *         """
 *         cdef PetscScalar sval = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal val1 = 0
 *         cdef PetscReal val2 = 0
 */
  __pyx_v_sval = 0.0;

  /* "SLEPc/RG.pyx":535
 *         """
 *         cdef PetscScalar sval = 0
 *         cdef PetscReal val1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal val2 = 0
 *         cdef PetscReal val3 = 0
 */
  __pyx_v_val1 = 0.0;

  /* "SLEPc/RG.pyx":536
 *         cdef PetscScalar sval = 0
 *         cdef PetscReal val1 = 0
 *         cdef PetscReal val2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal val3 = 0
 *         cdef PetscReal val4 = 0
 */
  __pyx_v_val2 = 0.0;

  /* "SLEPc/RG.pyx":537
 *         cdef PetscReal val1 = 0
 *         cdef PetscReal val2 = 0
 *         cdef PetscReal val3 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal val4 = 0
 *         cdef PetscReal val5 = 0
 */
  __pyx_v_val3 = 0.0;

  /* "SLEPc/RG.pyx":538
 *         cdef PetscReal val2 = 0
 *         cdef PetscReal val3 = 0
 *         cdef PetscReal val4 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal val5 = 0
 *         CHKERR( RGRingGetParameters(self.rg, &sval, &val1, &val2, &val3, &val4, &val5) )
 */
  __pyx_v_val4 = 0.0;

  /* "SLEPc/RG.pyx":539
 *         cdef PetscReal val3 = 0
 *         cdef PetscReal val4 = 0
 *         cdef PetscReal val5 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( RGRingGetParameters(self.rg, &sval, &val1, &val2, &val3, &val4, &val5) )
 *         return (toScalar(sval), toReal(val1), toReal(val2), toReal(val3), toReal(val4), toReal(val5))
 */
  __pyx_v_val5 = 0.0;

  /* "SLEPc/RG.pyx":540
 *         cdef PetscReal val4 = 0
 *         cdef PetscReal val5 = 0
 *         CHKERR( RGRingGetParameters(self.rg, &sval, &val1, &val2, &val3, &val4, &val5) )             # <<<<<<<<<<<<<<
 *         return (toScalar(sval), toReal(val1), toReal(val2), toReal(val3), toReal(val4), toReal(val5))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(RGRingGetParameters(__pyx_v_self->rg, (&__pyx_v_sval), (&__pyx_v_val1), (&__pyx_v_val2), (&__pyx_v_val3), (&__pyx_v_val4), (&__pyx_v_val5))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(16, 540, __pyx_L1_error)

  /* "SLEPc/RG.pyx":541
 *         cdef PetscReal val5 = 0
 *         CHKERR( RGRingGetParameters(self.rg, &sval, &val1, &val2, &val3, &val4, &val5) )
 *         return (toScalar(sval), toReal(val1), toReal(val2), toReal(val3), toReal(val4), toReal(val5))             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_sval); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 541, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val1); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 541, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val2); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 541, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val3); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 541, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val4); if (unlikely(!__pyx_t_6)) __PYX_ERR(16, 541, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val5); if (unlikely(!__pyx_t_7)) __PYX_ERR(16, 541, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = PyTuple_New(6); if (unlikely(!__pyx_t_8)) __PYX_ERR(16, 541, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_7);
  PyTuple_SET_ITEM(__pyx_t_8, 5, __pyx_t_7);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_t_6 = 0;
  __pyx_t_7 = 0;
  __pyx_r = __pyx_t_8;
  __pyx_t_8 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":515
 *         CHKERR( RGRingSetParameters(self.rg, sval, val1, val2, val3, val4, val5) )
 * 
 *     def getRingParameters(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the parameters that define the ring region.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.getRingParameters", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":546
 * 
 *     property complement:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getComplement()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_10complement_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_10complement_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_10complement___get__(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_10complement___get__(struct PySlepcRGObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/RG.pyx":547
 *     property complement:
 *         def __get__(self):
 *             return self.getComplement()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setComplement(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getComplement); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 547, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 547, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":546
 * 
 *     property complement:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getComplement()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.complement.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":548
 *         def __get__(self):
 *             return self.getComplement()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setComplement(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2RG_10complement_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2RG_10complement_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_10complement_2__set__(((struct PySlepcRGObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2RG_10complement_2__set__(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/RG.pyx":549
 *             return self.getComplement()
 *         def __set__(self, value):
 *             self.setComplement(value)             # <<<<<<<<<<<<<<
 * 
 *     property scale:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setComplement); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 549, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 549, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/RG.pyx":548
 *         def __get__(self):
 *             return self.getComplement()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setComplement(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.complement.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":552
 * 
 *     property scale:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getScale()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_5scale_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_2RG_5scale_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_5scale___get__(((struct PySlepcRGObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2RG_5scale___get__(struct PySlepcRGObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/RG.pyx":553
 *     property scale:
 *         def __get__(self):
 *             return self.getScale()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setScale(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getScale); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 553, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 553, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/RG.pyx":552
 * 
 *     property scale:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getScale()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.scale.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/RG.pyx":554
 *         def __get__(self):
 *             return self.getScale()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setScale(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_2RG_5scale_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_2RG_5scale_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2RG_5scale_2__set__(((struct PySlepcRGObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_2RG_5scale_2__set__(struct PySlepcRGObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/RG.pyx":555
 *             return self.getScale()
 *         def __set__(self, value):
 *             self.setScale(value)             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setScale); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 555, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 555, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/RG.pyx":554
 *         def __get__(self):
 *             return self.getScale()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setScale(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.RG.scale.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":268
 *     CISSExtraction      = EPSCISSExtraction
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.eps
 *         self.eps = NULL
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS___cinit__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS___cinit__(struct PySlepcEPSObject *__pyx_v_self) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "SLEPc/EPS.pyx":269
 * 
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.eps             # <<<<<<<<<<<<<<
 *         self.eps = NULL
 * 
 */
  __pyx_v_self->__pyx_base.obj = ((PetscObject *)(&__pyx_v_self->eps));

  /* "SLEPc/EPS.pyx":270
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.eps
 *         self.eps = NULL             # <<<<<<<<<<<<<<
 * 
 *     def view(self, Viewer viewer=None):
 */
  __pyx_v_self->eps = NULL;

  /* "SLEPc/EPS.pyx":268
 *     CISSExtraction      = EPSCISSExtraction
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.eps
 *         self.eps = NULL
 */

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":272
 *         self.eps = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the EPS data structure.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_2view[] = "EPS.view(self, Viewer viewer=None)\n\n        Prints the EPS data structure.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional.\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("view (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "view") < 0)) __PYX_ERR(17, 272, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("view", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 272, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(17, 272, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_2view(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_2view(struct PySlepcEPSObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("view", 0);

  /* "SLEPc/EPS.pyx":282
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSView(self.eps, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/EPS.pyx":283
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( EPSView(self.eps, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def destroy(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSView(__pyx_v_self->eps, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 283, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":272
 *         self.eps = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the EPS data structure.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":285
 *         CHKERR( EPSView(self.eps, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the EPS object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_4destroy[] = "EPS.destroy(self)\n\n        Destroys the EPS object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("destroy (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("destroy", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "destroy", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_4destroy(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_4destroy(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("destroy", 0);

  /* "SLEPc/EPS.pyx":289
 *         Destroys the EPS object.
 *         """
 *         CHKERR( EPSDestroy(&self.eps) )             # <<<<<<<<<<<<<<
 *         self.eps = NULL
 *         return self
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSDestroy((&__pyx_v_self->eps))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 289, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":290
 *         """
 *         CHKERR( EPSDestroy(&self.eps) )
 *         self.eps = NULL             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  __pyx_v_self->eps = NULL;

  /* "SLEPc/EPS.pyx":291
 *         CHKERR( EPSDestroy(&self.eps) )
 *         self.eps = NULL
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def reset(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":285
 *         CHKERR( EPSView(self.eps, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the EPS object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.destroy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":293
 *         return self
 * 
 *     def reset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Resets the EPS object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_7reset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_6reset[] = "EPS.reset(self)\n\n        Resets the EPS object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_7reset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("reset (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("reset", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "reset", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_6reset(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_6reset(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("reset", 0);

  /* "SLEPc/EPS.pyx":297
 *         Resets the EPS object.
 *         """
 *         CHKERR( EPSReset(self.eps) )             # <<<<<<<<<<<<<<
 * 
 *     def create(self, comm=None):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSReset(__pyx_v_self->eps)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 297, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":293
 *         return self
 * 
 *     def reset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Resets the EPS object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.reset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":299
 *         CHKERR( EPSReset(self.eps) )
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the EPS object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_9create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_8create[] = "EPS.create(self, comm=None)\n\n        Creates the EPS object.\n\n        Parameters\n        ----------\n        comm: MPI_Comm, optional\n              MPI communicator; if not provided, it defaults to all\n              processes.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_9create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comm = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comm,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comm);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create") < 0)) __PYX_ERR(17, 299, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_comm = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("create", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 299, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_8create(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_comm);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_8create(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_comm) {
  MPI_Comm __pyx_v_ccomm;
  EPS __pyx_v_neweps;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  MPI_Comm __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("create", 0);

  /* "SLEPc/EPS.pyx":309
 *               processes.
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())             # <<<<<<<<<<<<<<
 *         cdef SlepcEPS neweps = NULL
 *         CHKERR( EPSCreate(ccomm, &neweps) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_def_Comm(__pyx_v_comm, __pyx_f_8slepc4py_5SLEPc_SLEPC_COMM_DEFAULT()); if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 309, __pyx_L1_error)
  __pyx_v_ccomm = __pyx_t_1;

  /* "SLEPc/EPS.pyx":310
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcEPS neweps = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( EPSCreate(ccomm, &neweps) )
 *         SlepcCLEAR(self.obj); self.eps = neweps
 */
  __pyx_v_neweps = NULL;

  /* "SLEPc/EPS.pyx":311
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcEPS neweps = NULL
 *         CHKERR( EPSCreate(ccomm, &neweps) )             # <<<<<<<<<<<<<<
 *         SlepcCLEAR(self.obj); self.eps = neweps
 *         return self
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSCreate(__pyx_v_ccomm, (&__pyx_v_neweps))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 311, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":312
 *         cdef SlepcEPS neweps = NULL
 *         CHKERR( EPSCreate(ccomm, &neweps) )
 *         SlepcCLEAR(self.obj); self.eps = neweps             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_SlepcCLEAR(__pyx_v_self->__pyx_base.obj));
  __pyx_v_self->eps = __pyx_v_neweps;

  /* "SLEPc/EPS.pyx":313
 *         CHKERR( EPSCreate(ccomm, &neweps) )
 *         SlepcCLEAR(self.obj); self.eps = neweps
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def setType(self, eps_type):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":299
 *         CHKERR( EPSReset(self.eps) )
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the EPS object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":315
 *         return self
 * 
 *     def setType(self, eps_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the particular solver to be used in the EPS object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_11setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_10setType[] = "EPS.setType(self, eps_type)\n\n        Selects the particular solver to be used in the EPS object.\n\n        Parameters\n        ----------\n        eps_type: `EPS.Type` enumerate\n                  The solver to be used.\n\n        Notes\n        -----\n        See `EPS.Type` for available methods. The default is\n        `EPS.Type.KRYLOVSCHUR`.  Normally, it is best to use\n        `setFromOptions()` and then set the EPS type from the options\n        database rather than by using this routine.  Using the options\n        database provides the user with maximum flexibility in\n        evaluating the different available methods.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_11setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_eps_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_eps_type,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_eps_type)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setType") < 0)) __PYX_ERR(17, 315, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_eps_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 315, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_10setType(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_eps_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_10setType(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_eps_type) {
  const char* __pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setType", 0);
  __Pyx_INCREF(__pyx_v_eps_type);

  /* "SLEPc/EPS.pyx":333
 *         evaluating the different available methods.
 *         """
 *         cdef SlepcEPSType cval = NULL             # <<<<<<<<<<<<<<
 *         eps_type = str2bytes(eps_type, &cval)
 *         CHKERR( EPSSetType(self.eps, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/EPS.pyx":334
 *         """
 *         cdef SlepcEPSType cval = NULL
 *         eps_type = str2bytes(eps_type, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetType(self.eps, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_eps_type, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 334, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_eps_type, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":335
 *         cdef SlepcEPSType cval = NULL
 *         eps_type = str2bytes(eps_type, &cval)
 *         CHKERR( EPSSetType(self.eps, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getType(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetType(__pyx_v_self->eps, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 335, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":315
 *         return self
 * 
 *     def setType(self, eps_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the particular solver to be used in the EPS object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_eps_type);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":337
 *         CHKERR( EPSSetType(self.eps, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the EPS type of this object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_13getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_12getType[] = "EPS.getType(self)\n\n        Gets the EPS type of this object.\n\n        Returns\n        -------\n        type: `EPS.Type` enumerate\n              The solver currently being used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_13getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_12getType(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_12getType(struct PySlepcEPSObject *__pyx_v_self) {
  const char* __pyx_v_eps_type;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getType", 0);

  /* "SLEPc/EPS.pyx":346
 *               The solver currently being used.
 *         """
 *         cdef SlepcEPSType eps_type = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetType(self.eps, &eps_type) )
 *         return bytes2str(eps_type)
 */
  __pyx_v_eps_type = NULL;

  /* "SLEPc/EPS.pyx":347
 *         """
 *         cdef SlepcEPSType eps_type = NULL
 *         CHKERR( EPSGetType(self.eps, &eps_type) )             # <<<<<<<<<<<<<<
 *         return bytes2str(eps_type)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetType(__pyx_v_self->eps, (&__pyx_v_eps_type))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 347, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":348
 *         cdef SlepcEPSType eps_type = NULL
 *         CHKERR( EPSGetType(self.eps, &eps_type) )
 *         return bytes2str(eps_type)             # <<<<<<<<<<<<<<
 * 
 *     def getOptionsPrefix(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_eps_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":337
 *         CHKERR( EPSSetType(self.eps, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the EPS type of this object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":350
 *         return bytes2str(eps_type)
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all EPS options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_15getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_14getOptionsPrefix[] = "EPS.getOptionsPrefix(self)\n\n        Gets the prefix used for searching for all EPS options in the\n        database.\n\n        Returns\n        -------\n        prefix: string\n                The prefix string set for this EPS object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_15getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOptionsPrefix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOptionsPrefix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOptionsPrefix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_14getOptionsPrefix(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_14getOptionsPrefix(struct PySlepcEPSObject *__pyx_v_self) {
  const char *__pyx_v_prefix;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOptionsPrefix", 0);

  /* "SLEPc/EPS.pyx":360
 *                 The prefix string set for this EPS object.
 *         """
 *         cdef const_char *prefix = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetOptionsPrefix(self.eps, &prefix) )
 *         return bytes2str(prefix)
 */
  __pyx_v_prefix = NULL;

  /* "SLEPc/EPS.pyx":361
 *         """
 *         cdef const_char *prefix = NULL
 *         CHKERR( EPSGetOptionsPrefix(self.eps, &prefix) )             # <<<<<<<<<<<<<<
 *         return bytes2str(prefix)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetOptionsPrefix(__pyx_v_self->eps, (&__pyx_v_prefix))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 361, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":362
 *         cdef const_char *prefix = NULL
 *         CHKERR( EPSGetOptionsPrefix(self.eps, &prefix) )
 *         return bytes2str(prefix)             # <<<<<<<<<<<<<<
 * 
 *     def setOptionsPrefix(self, prefix):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_prefix); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 362, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":350
 *         return bytes2str(eps_type)
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all EPS options in the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":364
 *         return bytes2str(prefix)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all EPS options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_17setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_16setOptionsPrefix[] = "EPS.setOptionsPrefix(self, prefix)\n\n        Sets the prefix used for searching for all EPS options in the\n        database.\n\n        Parameters\n        ----------\n        prefix: string\n                The prefix string to prepend to all EPS option\n                requests.\n\n        Notes\n        -----\n        A hyphen (-) must NOT be given at the beginning of the prefix\n        name.  The first character of all runtime options is\n        AUTOMATICALLY the hyphen.\n\n        For example, to distinguish between the runtime options for\n        two different EPS contexts, one could call::\n\n            E1.setOptionsPrefix(\"eig1_\")\n            E2.setOptionsPrefix(\"eig2_\")\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_17setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOptionsPrefix") < 0)) __PYX_ERR(17, 364, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 364, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_16setOptionsPrefix(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_16setOptionsPrefix(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/EPS.pyx":387
 *             E2.setOptionsPrefix("eig2_")
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( EPSSetOptionsPrefix(self.eps, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/EPS.pyx":388
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetOptionsPrefix(self.eps, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 388, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":389
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( EPSSetOptionsPrefix(self.eps, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def appendOptionsPrefix(self, prefix):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetOptionsPrefix(__pyx_v_self->eps, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 389, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":364
 *         return bytes2str(prefix)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all EPS options in the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":391
 *         CHKERR( EPSSetOptionsPrefix(self.eps, cval) )
 * 
 *     def appendOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Appends to the prefix used for searching for all EPS options
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_19appendOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_18appendOptionsPrefix[] = "EPS.appendOptionsPrefix(self, prefix)\n\n        Appends to the prefix used for searching for all EPS options\n        in the database.\n\n        Parameters\n        ----------\n        prefix: string\n                The prefix string to prepend to all EPS option requests.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_19appendOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("appendOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "appendOptionsPrefix") < 0)) __PYX_ERR(17, 391, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("appendOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 391, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.appendOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_18appendOptionsPrefix(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_18appendOptionsPrefix(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("appendOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/EPS.pyx":401
 *                 The prefix string to prepend to all EPS option requests.
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( EPSAppendOptionsPrefix(self.eps, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/EPS.pyx":402
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSAppendOptionsPrefix(self.eps, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 402, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":403
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( EPSAppendOptionsPrefix(self.eps, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def setFromOptions(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSAppendOptionsPrefix(__pyx_v_self->eps, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 403, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":391
 *         CHKERR( EPSSetOptionsPrefix(self.eps, cval) )
 * 
 *     def appendOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Appends to the prefix used for searching for all EPS options
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.appendOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":405
 *         CHKERR( EPSAppendOptionsPrefix(self.eps, cval) )
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets EPS options from the options database. This routine must
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_21setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_20setFromOptions[] = "EPS.setFromOptions(self)\n\n        Sets EPS options from the options database. This routine must\n        be called before `setUp()` if the user is to be allowed to set\n        the solver type.\n\n        Notes\n        -----\n        To see all options, run your program with the ``-help``\n        option.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_21setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFromOptions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setFromOptions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setFromOptions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_20setFromOptions(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_20setFromOptions(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFromOptions", 0);

  /* "SLEPc/EPS.pyx":416
 *         option.
 *         """
 *         CHKERR( EPSSetFromOptions(self.eps) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetFromOptions(__pyx_v_self->eps)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 416, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":405
 *         CHKERR( EPSAppendOptionsPrefix(self.eps, cval) )
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets EPS options from the options database. This routine must
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setFromOptions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":420
 *     #
 * 
 *     def getProblemType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the problem type from the EPS object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_23getProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_22getProblemType[] = "EPS.getProblemType(self)\n\n        Gets the problem type from the EPS object.\n\n        Returns\n        -------\n        problem_type: `EPS.ProblemType` enumerate\n                      The problem type that was previously set.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_23getProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getProblemType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getProblemType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getProblemType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_22getProblemType(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_22getProblemType(struct PySlepcEPSObject *__pyx_v_self) {
  EPSProblemType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getProblemType", 0);

  /* "SLEPc/EPS.pyx":429
 *                       The problem type that was previously set.
 *         """
 *         cdef SlepcEPSProblemType val = EPS_NHEP             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetProblemType(self.eps, &val) )
 *         return val
 */
  __pyx_v_val = EPS_NHEP;

  /* "SLEPc/EPS.pyx":430
 *         """
 *         cdef SlepcEPSProblemType val = EPS_NHEP
 *         CHKERR( EPSGetProblemType(self.eps, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetProblemType(__pyx_v_self->eps, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 430, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":431
 *         cdef SlepcEPSProblemType val = EPS_NHEP
 *         CHKERR( EPSGetProblemType(self.eps, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setProblemType(self, problem_type):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_EPSProblemType(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 431, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":420
 *     #
 * 
 *     def getProblemType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the problem type from the EPS object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getProblemType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":433
 *         return val
 * 
 *     def setProblemType(self, problem_type):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the type of the eigenvalue problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_25setProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_24setProblemType[] = "EPS.setProblemType(self, problem_type)\n\n        Specifies the type of the eigenvalue problem.\n\n        Parameters\n        ----------\n        problem_type: `EPS.ProblemType` enumerate\n               The problem type to be set.\n\n        Notes\n        -----\n        Allowed values are: Hermitian (HEP), non-Hermitian (NHEP),\n        generalized Hermitian (GHEP), generalized non-Hermitian\n        (GNHEP), and generalized non-Hermitian with positive\n        semi-definite B (PGNHEP).\n\n        This function must be used to instruct SLEPc to exploit\n        symmetry. If no problem type is specified, by default a\n        non-Hermitian problem is assumed (either standard or\n        generalized). If the user knows that the problem is Hermitian\n        (i.e. ``A=A^H``) or generalized Hermitian (i.e. ``A=A^H``,\n        ``B=B^H``, and ``B`` positive definite) then it is recommended\n        to set the problem type so that eigensolver can exploit these\n        properties.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_25setProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_problem_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setProblemType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_problem_type,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_problem_type)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setProblemType") < 0)) __PYX_ERR(17, 433, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_problem_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setProblemType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 433, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setProblemType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_24setProblemType(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_problem_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_24setProblemType(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_problem_type) {
  EPSProblemType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  EPSProblemType __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setProblemType", 0);

  /* "SLEPc/EPS.pyx":458
 *         properties.
 *         """
 *         cdef SlepcEPSProblemType val = problem_type             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetProblemType(self.eps, val) )
 * 
 */
  __pyx_t_1 = ((EPSProblemType)__Pyx_PyInt_As_EPSProblemType(__pyx_v_problem_type)); if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 458, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":459
 *         """
 *         cdef SlepcEPSProblemType val = problem_type
 *         CHKERR( EPSSetProblemType(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def isGeneralized(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetProblemType(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 459, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":433
 *         return val
 * 
 *     def setProblemType(self, problem_type):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the type of the eigenvalue problem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setProblemType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":461
 *         CHKERR( EPSSetProblemType(self.eps, val) )
 * 
 *     def isGeneralized(self):             # <<<<<<<<<<<<<<
 *         """
 *         Tells whether the EPS object corresponds to a generalized
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_27isGeneralized(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_26isGeneralized[] = "EPS.isGeneralized(self)\n\n        Tells whether the EPS object corresponds to a generalized\n        eigenvalue problem.\n\n        Returns\n        -------\n        flag: bool\n              True if two matrices were set with `setOperators()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_27isGeneralized(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("isGeneralized (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("isGeneralized", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isGeneralized", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_26isGeneralized(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_26isGeneralized(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("isGeneralized", 0);

  /* "SLEPc/EPS.pyx":471
 *               True if two matrices were set with `setOperators()`.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSIsGeneralized(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":472
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSIsGeneralized(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSIsGeneralized(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 472, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":473
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSIsGeneralized(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def isHermitian(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 473, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":461
 *         CHKERR( EPSSetProblemType(self.eps, val) )
 * 
 *     def isGeneralized(self):             # <<<<<<<<<<<<<<
 *         """
 *         Tells whether the EPS object corresponds to a generalized
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.isGeneralized", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":475
 *         return toBool(tval)
 * 
 *     def isHermitian(self):             # <<<<<<<<<<<<<<
 *         """
 *         Tells whether the EPS object corresponds to a Hermitian
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_29isHermitian(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_28isHermitian[] = "EPS.isHermitian(self)\n\n        Tells whether the EPS object corresponds to a Hermitian\n        eigenvalue problem.\n\n        Returns\n        -------\n        flag: bool\n              True if the problem type set with `setProblemType()` was\n              Hermitian.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_29isHermitian(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("isHermitian (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("isHermitian", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isHermitian", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_28isHermitian(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_28isHermitian(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("isHermitian", 0);

  /* "SLEPc/EPS.pyx":486
 *               Hermitian.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSIsHermitian(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":487
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSIsHermitian(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSIsHermitian(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 487, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":488
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSIsHermitian(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def isPositive(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 488, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":475
 *         return toBool(tval)
 * 
 *     def isHermitian(self):             # <<<<<<<<<<<<<<
 *         """
 *         Tells whether the EPS object corresponds to a Hermitian
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.isHermitian", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":490
 *         return toBool(tval)
 * 
 *     def isPositive(self):             # <<<<<<<<<<<<<<
 *         """
 *         Tells whether the EPS object corresponds to an eigenvalue problem
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_31isPositive(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_30isPositive[] = "EPS.isPositive(self)\n\n        Tells whether the EPS object corresponds to an eigenvalue problem\n        type that requires a positive (semi-) definite matrix B.\n\n        Returns\n        -------\n        flag: bool\n              True if the problem type set with `setProblemType()` was\n              positive.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_31isPositive(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("isPositive (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("isPositive", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isPositive", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_30isPositive(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_30isPositive(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("isPositive", 0);

  /* "SLEPc/EPS.pyx":501
 *               positive.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSIsPositive(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":502
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSIsPositive(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSIsPositive(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 502, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":503
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSIsPositive(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def getBalance(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 503, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":490
 *         return toBool(tval)
 * 
 *     def isPositive(self):             # <<<<<<<<<<<<<<
 *         """
 *         Tells whether the EPS object corresponds to an eigenvalue problem
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.isPositive", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":505
 *         return toBool(tval)
 * 
 *     def getBalance(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the balancing type used by the EPS object,
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_33getBalance(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_32getBalance[] = "EPS.getBalance(self)\n\n        Gets the balancing type used by the EPS object,\n        and the associated parameters.\n\n        Returns\n        -------\n        balance: `EPS.Balance` enumerate\n                 The balancing method\n        iterations: int\n                    Number of iterations of the balancing algorithm\n        cutoff: real\n                Cutoff value\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_33getBalance(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getBalance (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getBalance", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBalance", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_32getBalance(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_32getBalance(struct PySlepcEPSObject *__pyx_v_self) {
  EPSBalance __pyx_v_val;
  PetscInt __pyx_v_ival;
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getBalance", 0);

  /* "SLEPc/EPS.pyx":519
 *                 Cutoff value
 *         """
 *         cdef SlepcEPSBalance val = EPS_BALANCE_ONESIDE             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival = 0
 *         cdef PetscReal rval = 0
 */
  __pyx_v_val = EPS_BALANCE_ONESIDE;

  /* "SLEPc/EPS.pyx":520
 *         """
 *         cdef SlepcEPSBalance val = EPS_BALANCE_ONESIDE
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval = 0
 *         CHKERR( EPSGetBalance(self.eps, &val, &ival, &rval) )
 */
  __pyx_v_ival = 0;

  /* "SLEPc/EPS.pyx":521
 *         cdef SlepcEPSBalance val = EPS_BALANCE_ONESIDE
 *         cdef PetscInt ival = 0
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetBalance(self.eps, &val, &ival, &rval) )
 *         return (val, toInt(ival), toReal(rval))
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/EPS.pyx":522
 *         cdef PetscInt ival = 0
 *         cdef PetscReal rval = 0
 *         CHKERR( EPSGetBalance(self.eps, &val, &ival, &rval) )             # <<<<<<<<<<<<<<
 *         return (val, toInt(ival), toReal(rval))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetBalance(__pyx_v_self->eps, (&__pyx_v_val), (&__pyx_v_ival), (&__pyx_v_rval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 522, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":523
 *         cdef PetscReal rval = 0
 *         CHKERR( EPSGetBalance(self.eps, &val, &ival, &rval) )
 *         return (val, toInt(ival), toReal(rval))             # <<<<<<<<<<<<<<
 * 
 *     def setBalance(self, balance=None, iterations=None, cutoff=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_EPSBalance(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 523, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 523, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 523, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(17, 523, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":505
 *         return toBool(tval)
 * 
 *     def getBalance(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the balancing type used by the EPS object,
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getBalance", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":525
 *         return (val, toInt(ival), toReal(rval))
 * 
 *     def setBalance(self, balance=None, iterations=None, cutoff=None):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the balancing technique to be employed by the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_35setBalance(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_34setBalance[] = "EPS.setBalance(self, balance=None, iterations=None, cutoff=None)\n\n        Specifies the balancing technique to be employed by the\n        eigensolver, and some parameters associated to it.\n\n        Parameters\n        ----------\n        balance: `EPS.Balance` enumerate\n                 The balancing method\n        iterations: int\n                    Number of iterations of the balancing algorithm\n        cutoff: real\n                Cutoff value\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_35setBalance(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_balance = 0;
  PyObject *__pyx_v_iterations = 0;
  PyObject *__pyx_v_cutoff = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setBalance (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_balance,&__pyx_n_s_iterations,&__pyx_n_s_cutoff,0};
    PyObject* values[3] = {0,0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_balance);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_iterations);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_cutoff);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setBalance") < 0)) __PYX_ERR(17, 525, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_balance = values[0];
    __pyx_v_iterations = values[1];
    __pyx_v_cutoff = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setBalance", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 525, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setBalance", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_34setBalance(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_balance, __pyx_v_iterations, __pyx_v_cutoff);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_34setBalance(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_balance, PyObject *__pyx_v_iterations, PyObject *__pyx_v_cutoff) {
  EPSBalance __pyx_v_val;
  PetscInt __pyx_v_ival;
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  EPSBalance __pyx_t_3;
  PetscInt __pyx_t_4;
  PetscReal __pyx_t_5;
  int __pyx_t_6;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setBalance", 0);

  /* "SLEPc/EPS.pyx":539
 *                 Cutoff value
 *         """
 *         cdef SlepcEPSBalance val = <SlepcEPSBalance>PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         cdef PetscReal rval = PETSC_DEFAULT
 */
  __pyx_v_val = ((EPSBalance)PETSC_DEFAULT);

  /* "SLEPc/EPS.pyx":540
 *         """
 *         cdef SlepcEPSBalance val = <SlepcEPSBalance>PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         if balance    is not None: val  = balance
 */
  __pyx_v_ival = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":541
 *         cdef SlepcEPSBalance val = <SlepcEPSBalance>PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         cdef PetscReal rval = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if balance    is not None: val  = balance
 *         if iterations is not None: ival = asInt(iterations)
 */
  __pyx_v_rval = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":542
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         if balance    is not None: val  = balance             # <<<<<<<<<<<<<<
 *         if iterations is not None: ival = asInt(iterations)
 *         if cutoff     is not None: rval = asReal(cutoff)
 */
  __pyx_t_1 = (__pyx_v_balance != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = ((EPSBalance)__Pyx_PyInt_As_EPSBalance(__pyx_v_balance)); if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 542, __pyx_L1_error)
    __pyx_v_val = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":543
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         if balance    is not None: val  = balance
 *         if iterations is not None: ival = asInt(iterations)             # <<<<<<<<<<<<<<
 *         if cutoff     is not None: rval = asReal(cutoff)
 *         CHKERR( EPSSetBalance(self.eps, val, ival, rval) )
 */
  __pyx_t_2 = (__pyx_v_iterations != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_iterations); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 543, __pyx_L1_error)
    __pyx_v_ival = __pyx_t_4;
  }

  /* "SLEPc/EPS.pyx":544
 *         if balance    is not None: val  = balance
 *         if iterations is not None: ival = asInt(iterations)
 *         if cutoff     is not None: rval = asReal(cutoff)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetBalance(self.eps, val, ival, rval) )
 * 
 */
  __pyx_t_1 = (__pyx_v_cutoff != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_cutoff); if (unlikely(__pyx_t_5 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(17, 544, __pyx_L1_error)
    __pyx_v_rval = __pyx_t_5;
  }

  /* "SLEPc/EPS.pyx":545
 *         if iterations is not None: ival = asInt(iterations)
 *         if cutoff     is not None: rval = asReal(cutoff)
 *         CHKERR( EPSSetBalance(self.eps, val, ival, rval) )             # <<<<<<<<<<<<<<
 * 
 *     def getExtraction(self):
 */
  __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetBalance(__pyx_v_self->eps, __pyx_v_val, __pyx_v_ival, __pyx_v_rval)); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(17, 545, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":525
 *         return (val, toInt(ival), toReal(rval))
 * 
 *     def setBalance(self, balance=None, iterations=None, cutoff=None):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the balancing technique to be employed by the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setBalance", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":547
 *         CHKERR( EPSSetBalance(self.eps, val, ival, rval) )
 * 
 *     def getExtraction(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the extraction type used by the EPS object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_37getExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_36getExtraction[] = "EPS.getExtraction(self)\n\n        Gets the extraction type used by the EPS object.\n\n        Returns\n        -------\n        extraction: `EPS.Extraction` enumerate\n                    The method of extraction.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_37getExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getExtraction (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getExtraction", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getExtraction", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_36getExtraction(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_36getExtraction(struct PySlepcEPSObject *__pyx_v_self) {
  EPSExtraction __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getExtraction", 0);

  /* "SLEPc/EPS.pyx":556
 *                     The method of extraction.
 *         """
 *         cdef SlepcEPSExtraction val = EPS_RITZ             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetExtraction(self.eps, &val) )
 *         return val
 */
  __pyx_v_val = EPS_RITZ;

  /* "SLEPc/EPS.pyx":557
 *         """
 *         cdef SlepcEPSExtraction val = EPS_RITZ
 *         CHKERR( EPSGetExtraction(self.eps, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetExtraction(__pyx_v_self->eps, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 557, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":558
 *         cdef SlepcEPSExtraction val = EPS_RITZ
 *         CHKERR( EPSGetExtraction(self.eps, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setExtraction(self, extraction):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_EPSExtraction(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 558, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":547
 *         CHKERR( EPSSetBalance(self.eps, val, ival, rval) )
 * 
 *     def getExtraction(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the extraction type used by the EPS object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getExtraction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":560
 *         return val
 * 
 *     def setExtraction(self, extraction):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the extraction type used by the EPS object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_39setExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_38setExtraction[] = "EPS.setExtraction(self, extraction)\n\n        Sets the extraction type used by the EPS object.\n\n        Parameters\n        ----------\n        extraction: `EPS.Extraction` enumerate\n                    The extraction method to be used by the solver.\n\n        Notes\n        -----\n        Not all eigensolvers support all types of extraction. See the\n        SLEPc documentation for details.\n\n        By default, a standard Rayleigh-Ritz extraction is used. Other\n        extractions may be useful when computing interior eigenvalues.\n\n        Harmonic-type extractions are used in combination with a\n        *target*. See `setTarget()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_39setExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_extraction = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setExtraction (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_extraction,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_extraction)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setExtraction") < 0)) __PYX_ERR(17, 560, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_extraction = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setExtraction", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 560, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setExtraction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_38setExtraction(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_extraction);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_38setExtraction(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_extraction) {
  EPSExtraction __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  EPSExtraction __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setExtraction", 0);

  /* "SLEPc/EPS.pyx":580
 *         *target*. See `setTarget()`.
 *         """
 *         cdef SlepcEPSExtraction val = extraction             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetExtraction(self.eps, val) )
 * 
 */
  __pyx_t_1 = ((EPSExtraction)__Pyx_PyInt_As_EPSExtraction(__pyx_v_extraction)); if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 580, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":581
 *         """
 *         cdef SlepcEPSExtraction val = extraction
 *         CHKERR( EPSSetExtraction(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getWhichEigenpairs(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetExtraction(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 581, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":560
 *         return val
 * 
 *     def setExtraction(self, extraction):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the extraction type used by the EPS object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setExtraction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":583
 *         CHKERR( EPSSetExtraction(self.eps, val) )
 * 
 *     def getWhichEigenpairs(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns which portion of the spectrum is to be sought.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_41getWhichEigenpairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_40getWhichEigenpairs[] = "EPS.getWhichEigenpairs(self)\n\n        Returns which portion of the spectrum is to be sought.\n\n        Returns\n        -------\n        which: `EPS.Which` enumerate\n               The portion of the spectrum to be sought by the solver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_41getWhichEigenpairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getWhichEigenpairs (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getWhichEigenpairs", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getWhichEigenpairs", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_40getWhichEigenpairs(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_40getWhichEigenpairs(struct PySlepcEPSObject *__pyx_v_self) {
  EPSWhich __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getWhichEigenpairs", 0);

  /* "SLEPc/EPS.pyx":592
 *                The portion of the spectrum to be sought by the solver.
 *         """
 *         cdef SlepcEPSWhich val = EPS_LARGEST_MAGNITUDE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetWhichEigenpairs(self.eps, &val) )
 *         return val
 */
  __pyx_v_val = EPS_LARGEST_MAGNITUDE;

  /* "SLEPc/EPS.pyx":593
 *         """
 *         cdef SlepcEPSWhich val = EPS_LARGEST_MAGNITUDE
 *         CHKERR( EPSGetWhichEigenpairs(self.eps, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetWhichEigenpairs(__pyx_v_self->eps, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 593, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":594
 *         cdef SlepcEPSWhich val = EPS_LARGEST_MAGNITUDE
 *         CHKERR( EPSGetWhichEigenpairs(self.eps, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setWhichEigenpairs(self, which):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_EPSWhich(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 594, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":583
 *         CHKERR( EPSSetExtraction(self.eps, val) )
 * 
 *     def getWhichEigenpairs(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns which portion of the spectrum is to be sought.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getWhichEigenpairs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":596
 *         return val
 * 
 *     def setWhichEigenpairs(self, which):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies which portion of the spectrum is to be sought.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_43setWhichEigenpairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_42setWhichEigenpairs[] = "EPS.setWhichEigenpairs(self, which)\n\n        Specifies which portion of the spectrum is to be sought.\n\n        Parameters\n        ----------\n        which: `EPS.Which` enumerate\n               The portion of the spectrum to be sought by the solver.\n\n        Notes\n        -----\n        Not all eigensolvers implemented in EPS account for all the\n        possible values. Also, some values make sense only for certain\n        types of problems. If SLEPc is compiled for real numbers\n        `EPS.Which.LARGEST_IMAGINARY` and\n        `EPS.Which.SMALLEST_IMAGINARY` use the absolute value of the\n        imaginary part for eigenvalue selection.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_43setWhichEigenpairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_which = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setWhichEigenpairs (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_which,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_which)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setWhichEigenpairs") < 0)) __PYX_ERR(17, 596, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_which = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setWhichEigenpairs", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 596, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setWhichEigenpairs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_42setWhichEigenpairs(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_which);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_42setWhichEigenpairs(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_which) {
  EPSWhich __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  EPSWhich __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setWhichEigenpairs", 0);

  /* "SLEPc/EPS.pyx":614
 *         imaginary part for eigenvalue selection.
 *         """
 *         cdef SlepcEPSWhich val = which             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetWhichEigenpairs(self.eps, val) )
 * 
 */
  __pyx_t_1 = ((EPSWhich)__Pyx_PyInt_As_EPSWhich(__pyx_v_which)); if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 614, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":615
 *         """
 *         cdef SlepcEPSWhich val = which
 *         CHKERR( EPSSetWhichEigenpairs(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getTarget(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetWhichEigenpairs(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 615, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":596
 *         return val
 * 
 *     def setWhichEigenpairs(self, which):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies which portion of the spectrum is to be sought.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setWhichEigenpairs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":617
 *         CHKERR( EPSSetWhichEigenpairs(self.eps, val) )
 * 
 *     def getTarget(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the value of the target.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_45getTarget(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_44getTarget[] = "EPS.getTarget(self)\n\n        Gets the value of the target.\n\n        Returns\n        -------\n        target: float (real or complex)\n                The value of the target.\n\n        Notes\n        -----\n        If the target was not set by the user, then zero is returned.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_45getTarget(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTarget (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTarget", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTarget", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_44getTarget(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_44getTarget(struct PySlepcEPSObject *__pyx_v_self) {
  PetscScalar __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTarget", 0);

  /* "SLEPc/EPS.pyx":630
 *         If the target was not set by the user, then zero is returned.
 *         """
 *         cdef PetscScalar sval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetTarget(self.eps, &sval) )
 *         return toScalar(sval)
 */
  __pyx_v_sval = 0.0;

  /* "SLEPc/EPS.pyx":631
 *         """
 *         cdef PetscScalar sval = 0
 *         CHKERR( EPSGetTarget(self.eps, &sval) )             # <<<<<<<<<<<<<<
 *         return toScalar(sval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetTarget(__pyx_v_self->eps, (&__pyx_v_sval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 631, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":632
 *         cdef PetscScalar sval = 0
 *         CHKERR( EPSGetTarget(self.eps, &sval) )
 *         return toScalar(sval)             # <<<<<<<<<<<<<<
 * 
 *     def setTarget(self, target):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_sval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 632, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":617
 *         CHKERR( EPSSetWhichEigenpairs(self.eps, val) )
 * 
 *     def getTarget(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the value of the target.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getTarget", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":634
 *         return toScalar(sval)
 * 
 *     def setTarget(self, target):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the value of the target.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_47setTarget(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_46setTarget[] = "EPS.setTarget(self, target)\n\n        Sets the value of the target.\n\n        Parameters\n        ----------\n        target: float (real or complex)\n                The value of the target.\n\n        Notes\n        -----\n        The target is a scalar value used to determine the portion of\n        the spectrum of interest. It is used in combination with\n        `setWhichEigenpairs()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_47setTarget(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_target = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTarget (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_target,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_target)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTarget") < 0)) __PYX_ERR(17, 634, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_target = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTarget", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 634, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setTarget", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_46setTarget(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_target);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_46setTarget(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_target) {
  PetscScalar __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTarget", 0);

  /* "SLEPc/EPS.pyx":649
 *         `setWhichEigenpairs()`.
 *         """
 *         cdef PetscScalar sval = asScalar(target)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetTarget(self.eps, sval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_target); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(17, 649, __pyx_L1_error)
  __pyx_v_sval = __pyx_t_1;

  /* "SLEPc/EPS.pyx":650
 *         """
 *         cdef PetscScalar sval = asScalar(target)
 *         CHKERR( EPSSetTarget(self.eps, sval) )             # <<<<<<<<<<<<<<
 * 
 *     def getInterval(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetTarget(__pyx_v_self->eps, __pyx_v_sval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 650, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":634
 *         return toScalar(sval)
 * 
 *     def setTarget(self, target):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the value of the target.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setTarget", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":652
 *         CHKERR( EPSSetTarget(self.eps, sval) )
 * 
 *     def getInterval(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the computational interval for spectrum slicing.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_49getInterval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_48getInterval[] = "EPS.getInterval(self)\n\n        Gets the computational interval for spectrum slicing.\n\n        Returns\n        -------\n        inta: float\n                The left end of the interval.\n        intb: float\n                The right end of the interval.\n\n        Notes\n        -----\n        If the interval was not set by the user, then zeros are returned.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_49getInterval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getInterval (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getInterval", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getInterval", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_48getInterval(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_48getInterval(struct PySlepcEPSObject *__pyx_v_self) {
  PetscReal __pyx_v_inta;
  PetscReal __pyx_v_intb;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getInterval", 0);

  /* "SLEPc/EPS.pyx":667
 *         If the interval was not set by the user, then zeros are returned.
 *         """
 *         cdef PetscReal inta = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal intb = 0
 *         CHKERR( EPSGetInterval(self.eps, &inta, &intb) )
 */
  __pyx_v_inta = 0.0;

  /* "SLEPc/EPS.pyx":668
 *         """
 *         cdef PetscReal inta = 0
 *         cdef PetscReal intb = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetInterval(self.eps, &inta, &intb) )
 *         return (toReal(inta), toReal(intb))
 */
  __pyx_v_intb = 0.0;

  /* "SLEPc/EPS.pyx":669
 *         cdef PetscReal inta = 0
 *         cdef PetscReal intb = 0
 *         CHKERR( EPSGetInterval(self.eps, &inta, &intb) )             # <<<<<<<<<<<<<<
 *         return (toReal(inta), toReal(intb))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetInterval(__pyx_v_self->eps, (&__pyx_v_inta), (&__pyx_v_intb))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 669, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":670
 *         cdef PetscReal intb = 0
 *         CHKERR( EPSGetInterval(self.eps, &inta, &intb) )
 *         return (toReal(inta), toReal(intb))             # <<<<<<<<<<<<<<
 * 
 *     def setInterval(self, inta, intb):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_inta); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 670, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_intb); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 670, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 670, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":652
 *         CHKERR( EPSSetTarget(self.eps, sval) )
 * 
 *     def getInterval(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the computational interval for spectrum slicing.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getInterval", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":672
 *         return (toReal(inta), toReal(intb))
 * 
 *     def setInterval(self, inta, intb):             # <<<<<<<<<<<<<<
 *         """
 *         Defines the computational interval for spectrum slicing.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_51setInterval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_50setInterval[] = "EPS.setInterval(self, inta, intb)\n\n        Defines the computational interval for spectrum slicing.\n\n        Parameters\n        ----------\n        inta: float\n                The left end of the interval.\n        intb: float\n                The right end of the interval.\n\n        Notes\n        -----\n        Spectrum slicing is a technique employed for computing all\n        eigenvalues of symmetric eigenproblems in a given interval.\n        This function provides the interval to be considered. It must\n        be used in combination with `EPS.Which.ALL`, see\n        `setWhichEigenpairs()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_51setInterval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_inta = 0;
  PyObject *__pyx_v_intb = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setInterval (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inta,&__pyx_n_s_intb,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_inta)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_intb)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setInterval", 1, 2, 2, 1); __PYX_ERR(17, 672, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setInterval") < 0)) __PYX_ERR(17, 672, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_inta = values[0];
    __pyx_v_intb = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setInterval", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 672, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setInterval", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_50setInterval(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_inta, __pyx_v_intb);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_50setInterval(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_inta, PyObject *__pyx_v_intb) {
  PetscReal __pyx_v_rval1;
  PetscReal __pyx_v_rval2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setInterval", 0);

  /* "SLEPc/EPS.pyx":691
 *         `setWhichEigenpairs()`.
 *         """
 *         cdef PetscReal rval1 = asReal(inta)             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval2 = asReal(intb)
 *         CHKERR( EPSSetInterval(self.eps, rval1, rval2) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_inta); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(17, 691, __pyx_L1_error)
  __pyx_v_rval1 = __pyx_t_1;

  /* "SLEPc/EPS.pyx":692
 *         """
 *         cdef PetscReal rval1 = asReal(inta)
 *         cdef PetscReal rval2 = asReal(intb)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetInterval(self.eps, rval1, rval2) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_intb); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(17, 692, __pyx_L1_error)
  __pyx_v_rval2 = __pyx_t_1;

  /* "SLEPc/EPS.pyx":693
 *         cdef PetscReal rval1 = asReal(inta)
 *         cdef PetscReal rval2 = asReal(intb)
 *         CHKERR( EPSSetInterval(self.eps, rval1, rval2) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetInterval(__pyx_v_self->eps, __pyx_v_rval1, __pyx_v_rval2)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 693, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":672
 *         return (toReal(inta), toReal(intb))
 * 
 *     def setInterval(self, inta, intb):             # <<<<<<<<<<<<<<
 *         """
 *         Defines the computational interval for spectrum slicing.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setInterval", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":697
 *     #
 * 
 *     def getTolerances(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance and maximum iteration count used by the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_53getTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_52getTolerances[] = "EPS.getTolerances(self)\n\n        Gets the tolerance and maximum iteration count used by the\n        default EPS convergence tests.\n\n        Returns\n        -------\n        tol: float\n             The convergence tolerance.\n        max_it: int\n             The maximum number of iterations\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_53getTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTolerances (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTolerances", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTolerances", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_52getTolerances(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_52getTolerances(struct PySlepcEPSObject *__pyx_v_self) {
  PetscReal __pyx_v_rval;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTolerances", 0);

  /* "SLEPc/EPS.pyx":709
 *              The maximum number of iterations
 *         """
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = 0
 *         CHKERR( EPSGetTolerances(self.eps, &rval, &ival) )
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/EPS.pyx":710
 *         """
 *         cdef PetscReal rval = 0
 *         cdef PetscInt  ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetTolerances(self.eps, &rval, &ival) )
 *         return (toReal(rval), toInt(ival))
 */
  __pyx_v_ival = 0;

  /* "SLEPc/EPS.pyx":711
 *         cdef PetscReal rval = 0
 *         cdef PetscInt  ival = 0
 *         CHKERR( EPSGetTolerances(self.eps, &rval, &ival) )             # <<<<<<<<<<<<<<
 *         return (toReal(rval), toInt(ival))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetTolerances(__pyx_v_self->eps, (&__pyx_v_rval), (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 711, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":712
 *         cdef PetscInt  ival = 0
 *         CHKERR( EPSGetTolerances(self.eps, &rval, &ival) )
 *         return (toReal(rval), toInt(ival))             # <<<<<<<<<<<<<<
 * 
 *     def setTolerances(self, tol=None, max_it=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 712, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 712, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 712, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":697
 *     #
 * 
 *     def getTolerances(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance and maximum iteration count used by the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":714
 *         return (toReal(rval), toInt(ival))
 * 
 *     def setTolerances(self, tol=None, max_it=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance and maximum iteration count used by the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_55setTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_54setTolerances[] = "EPS.setTolerances(self, tol=None, max_it=None)\n\n        Sets the tolerance and maximum iteration count used by the\n        default EPS convergence tests.\n\n        Parameters\n        ----------\n        tol: float, optional\n             The convergence tolerance.\n        max_it: int, optional\n             The maximum number of iterations\n\n        Notes\n        -----\n        Use `DECIDE` for maxits to assign a reasonably good value,\n        which is dependent on the solution method.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_55setTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_tol = 0;
  PyObject *__pyx_v_max_it = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTolerances (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_tol,&__pyx_n_s_max_it,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tol);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_it);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTolerances") < 0)) __PYX_ERR(17, 714, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_tol = values[0];
    __pyx_v_max_it = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTolerances", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 714, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_54setTolerances(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_tol, __pyx_v_max_it);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_54setTolerances(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_tol, PyObject *__pyx_v_max_it) {
  PetscReal __pyx_v_rval;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscReal __pyx_t_3;
  PetscInt __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTolerances", 0);

  /* "SLEPc/EPS.pyx":731
 *         which is dependent on the solution method.
 *         """
 *         cdef PetscReal rval = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol    is not None: rval = asReal(tol)
 */
  __pyx_v_rval = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":732
 *         """
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if tol    is not None: rval = asReal(tol)
 *         if max_it is not None: ival = asInt(max_it)
 */
  __pyx_v_ival = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":733
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol    is not None: rval = asReal(tol)             # <<<<<<<<<<<<<<
 *         if max_it is not None: ival = asInt(max_it)
 *         CHKERR( EPSSetTolerances(self.eps, rval, ival) )
 */
  __pyx_t_1 = (__pyx_v_tol != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_tol); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(17, 733, __pyx_L1_error)
    __pyx_v_rval = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":734
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol    is not None: rval = asReal(tol)
 *         if max_it is not None: ival = asInt(max_it)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetTolerances(self.eps, rval, ival) )
 * 
 */
  __pyx_t_2 = (__pyx_v_max_it != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_max_it); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 734, __pyx_L1_error)
    __pyx_v_ival = __pyx_t_4;
  }

  /* "SLEPc/EPS.pyx":735
 *         if tol    is not None: rval = asReal(tol)
 *         if max_it is not None: ival = asInt(max_it)
 *         CHKERR( EPSSetTolerances(self.eps, rval, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getTwoSided(self):
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetTolerances(__pyx_v_self->eps, __pyx_v_rval, __pyx_v_ival)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(17, 735, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":714
 *         return (toReal(rval), toInt(ival))
 * 
 *     def setTolerances(self, tol=None, max_it=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance and maximum iteration count used by the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":737
 *         CHKERR( EPSSetTolerances(self.eps, rval, ival) )
 * 
 *     def getTwoSided(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether a two-sided variant
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_57getTwoSided(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_56getTwoSided[] = "EPS.getTwoSided(self)\n\n        Returns the flag indicating whether a two-sided variant\n        of the algorithm is being used or not.\n\n        Returns\n        -------\n        twosided: bool\n            Whether the two-sided variant is to be used or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_57getTwoSided(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTwoSided (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTwoSided", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTwoSided", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_56getTwoSided(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_56getTwoSided(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTwoSided", 0);

  /* "SLEPc/EPS.pyx":747
 *             Whether the two-sided variant is to be used or not.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetTwoSided(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":748
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSGetTwoSided(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetTwoSided(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 748, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":749
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSGetTwoSided(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setTwoSided(self, twosided):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 749, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":737
 *         CHKERR( EPSSetTolerances(self.eps, rval, ival) )
 * 
 *     def getTwoSided(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether a two-sided variant
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getTwoSided", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":751
 *         return toBool(tval)
 * 
 *     def setTwoSided(self, twosided):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the solver to use a two-sided variant so that left
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_59setTwoSided(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_58setTwoSided[] = "EPS.setTwoSided(self, twosided)\n\n        Sets the solver to use a two-sided variant so that left\n        eigenvectors are also computed.\n\n        Parameters\n        ----------\n        twosided: bool\n            Whether the two-sided variant is to be used or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_59setTwoSided(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_twosided = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTwoSided (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_twosided,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_twosided)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTwoSided") < 0)) __PYX_ERR(17, 751, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_twosided = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTwoSided", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 751, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setTwoSided", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_58setTwoSided(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_twosided);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_58setTwoSided(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_twosided) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTwoSided", 0);

  /* "SLEPc/EPS.pyx":761
 *             Whether the two-sided variant is to be used or not.
 *         """
 *         cdef PetscBool tval = asBool(twosided)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetTwoSided(self.eps, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_twosided); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 761, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/EPS.pyx":762
 *         """
 *         cdef PetscBool tval = asBool(twosided)
 *         CHKERR( EPSSetTwoSided(self.eps, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getPurify(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetTwoSided(__pyx_v_self->eps, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 762, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":751
 *         return toBool(tval)
 * 
 *     def setTwoSided(self, twosided):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the solver to use a two-sided variant so that left
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setTwoSided", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":764
 *         CHKERR( EPSSetTwoSided(self.eps, tval) )
 * 
 *     def getPurify(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether purification is activated
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_61getPurify(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_60getPurify[] = "EPS.getPurify(self)\n\n        Returns the flag indicating whether purification is activated\n        or not.\n\n        Returns\n        -------\n        purify: bool\n            Whether purification is activated or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_61getPurify(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getPurify (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getPurify", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getPurify", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_60getPurify(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_60getPurify(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getPurify", 0);

  /* "SLEPc/EPS.pyx":774
 *             Whether purification is activated or not.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetPurify(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":775
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSGetPurify(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetPurify(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 775, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":776
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSGetPurify(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setPurify(self, purify=True):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 776, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":764
 *         CHKERR( EPSSetTwoSided(self.eps, tval) )
 * 
 *     def getPurify(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether purification is activated
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getPurify", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":778
 *         return toBool(tval)
 * 
 *     def setPurify(self, purify=True):             # <<<<<<<<<<<<<<
 *         """
 *         Activate or deactivate eigenvector purification.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_63setPurify(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_62setPurify[] = "EPS.setPurify(self, purify=True)\n\n        Activate or deactivate eigenvector purification.\n\n        Parameters\n        ----------\n        purify: bool, optional\n            True to activate purification (default).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_63setPurify(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_purify = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setPurify (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_purify,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_purify);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setPurify") < 0)) __PYX_ERR(17, 778, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_purify = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setPurify", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 778, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setPurify", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_62setPurify(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_purify);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_62setPurify(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_purify) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setPurify", 0);

  /* "SLEPc/EPS.pyx":787
 *             True to activate purification (default).
 *         """
 *         cdef PetscBool tval = asBool(purify)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetPurify(self.eps, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_purify); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 787, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/EPS.pyx":788
 *         """
 *         cdef PetscBool tval = asBool(purify)
 *         CHKERR( EPSSetPurify(self.eps, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getConvergenceTest(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetPurify(__pyx_v_self->eps, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 788, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":778
 *         return toBool(tval)
 * 
 *     def setPurify(self, purify=True):             # <<<<<<<<<<<<<<
 *         """
 *         Activate or deactivate eigenvector purification.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setPurify", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":790
 *         CHKERR( EPSSetPurify(self.eps, tval) )
 * 
 *     def getConvergenceTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Return the method used to compute the error estimate
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_65getConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_64getConvergenceTest[] = "EPS.getConvergenceTest(self)\n\n        Return the method used to compute the error estimate\n        used in the convergence test.\n\n        Returns\n        -------\n        conv: EPS.Conv\n            The method used to compute the error estimate\n            used in the convergence test.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_65getConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getConvergenceTest (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getConvergenceTest", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConvergenceTest", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_64getConvergenceTest(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_64getConvergenceTest(struct PySlepcEPSObject *__pyx_v_self) {
  EPSConv __pyx_v_conv;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getConvergenceTest", 0);

  /* "SLEPc/EPS.pyx":801
 *             used in the convergence test.
 *         """
 *         cdef SlepcEPSConv conv = EPS_CONV_REL             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetConvergenceTest(self.eps, &conv) )
 *         return conv
 */
  __pyx_v_conv = EPS_CONV_REL;

  /* "SLEPc/EPS.pyx":802
 *         """
 *         cdef SlepcEPSConv conv = EPS_CONV_REL
 *         CHKERR( EPSGetConvergenceTest(self.eps, &conv) )             # <<<<<<<<<<<<<<
 *         return conv
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetConvergenceTest(__pyx_v_self->eps, (&__pyx_v_conv))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 802, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":803
 *         cdef SlepcEPSConv conv = EPS_CONV_REL
 *         CHKERR( EPSGetConvergenceTest(self.eps, &conv) )
 *         return conv             # <<<<<<<<<<<<<<
 * 
 *     def setConvergenceTest(self, conv):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_EPSConv(__pyx_v_conv); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 803, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":790
 *         CHKERR( EPSSetPurify(self.eps, tval) )
 * 
 *     def getConvergenceTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Return the method used to compute the error estimate
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getConvergenceTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":805
 *         return conv
 * 
 *     def setConvergenceTest(self, conv):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies how to compute the error estimate
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_67setConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_66setConvergenceTest[] = "EPS.setConvergenceTest(self, conv)\n\n        Specifies how to compute the error estimate\n        used in the convergence test.\n\n        Parameters\n        ----------\n        conv: EPS.Conv\n            The method used to compute the error estimate\n            used in the convergence test.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_67setConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_conv = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setConvergenceTest (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_conv,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_conv)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setConvergenceTest") < 0)) __PYX_ERR(17, 805, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_conv = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setConvergenceTest", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 805, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setConvergenceTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_66setConvergenceTest(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_conv);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_66setConvergenceTest(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_conv) {
  EPSConv __pyx_v_tconv;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  EPSConv __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setConvergenceTest", 0);

  /* "SLEPc/EPS.pyx":816
 *             used in the convergence test.
 *         """
 *         cdef SlepcEPSConv tconv = conv             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetConvergenceTest(self.eps, tconv) )
 * 
 */
  __pyx_t_1 = ((EPSConv)__Pyx_PyInt_As_EPSConv(__pyx_v_conv)); if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 816, __pyx_L1_error)
  __pyx_v_tconv = __pyx_t_1;

  /* "SLEPc/EPS.pyx":817
 *         """
 *         cdef SlepcEPSConv tconv = conv
 *         CHKERR( EPSSetConvergenceTest(self.eps, tconv) )             # <<<<<<<<<<<<<<
 * 
 *     def getTrueResidual(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetConvergenceTest(__pyx_v_self->eps, __pyx_v_tconv)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 817, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":805
 *         return conv
 * 
 *     def setConvergenceTest(self, conv):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies how to compute the error estimate
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setConvergenceTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":819
 *         CHKERR( EPSSetConvergenceTest(self.eps, tconv) )
 * 
 *     def getTrueResidual(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether true residual must be
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_69getTrueResidual(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_68getTrueResidual[] = "EPS.getTrueResidual(self)\n\n        Returns the flag indicating whether true residual must be\n        computed explicitly or not.\n\n        Returns\n        -------\n        trueres: bool\n            Whether the solver compute all residuals or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_69getTrueResidual(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTrueResidual (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTrueResidual", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTrueResidual", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_68getTrueResidual(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_68getTrueResidual(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTrueResidual", 0);

  /* "SLEPc/EPS.pyx":829
 *             Whether the solver compute all residuals or not.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetTrueResidual(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":830
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSGetTrueResidual(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetTrueResidual(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 830, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":831
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSGetTrueResidual(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setTrueResidual(self, trueres):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 831, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":819
 *         CHKERR( EPSSetConvergenceTest(self.eps, tconv) )
 * 
 *     def getTrueResidual(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether true residual must be
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getTrueResidual", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":833
 *         return toBool(tval)
 * 
 *     def setTrueResidual(self, trueres):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies if the solver must compute the true residual
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_71setTrueResidual(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_70setTrueResidual[] = "EPS.setTrueResidual(self, trueres)\n\n        Specifies if the solver must compute the true residual\n        explicitly or not.\n\n        Parameters\n        ----------\n        trueres: bool\n            Whether compute the true residual or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_71setTrueResidual(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_trueres = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTrueResidual (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_trueres,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_trueres)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTrueResidual") < 0)) __PYX_ERR(17, 833, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_trueres = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTrueResidual", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 833, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setTrueResidual", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_70setTrueResidual(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_trueres);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_70setTrueResidual(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_trueres) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTrueResidual", 0);

  /* "SLEPc/EPS.pyx":843
 *             Whether compute the true residual or not.
 *         """
 *         cdef PetscBool tval = asBool(trueres)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetTrueResidual(self.eps, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_trueres); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 843, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/EPS.pyx":844
 *         """
 *         cdef PetscBool tval = asBool(trueres)
 *         CHKERR( EPSSetTrueResidual(self.eps, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getTrackAll(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetTrueResidual(__pyx_v_self->eps, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 844, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":833
 *         return toBool(tval)
 * 
 *     def setTrueResidual(self, trueres):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies if the solver must compute the true residual
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setTrueResidual", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":846
 *         CHKERR( EPSSetTrueResidual(self.eps, tval) )
 * 
 *     def getTrackAll(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether all residual norms must be
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_73getTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_72getTrackAll[] = "EPS.getTrackAll(self)\n\n        Returns the flag indicating whether all residual norms must be\n        computed or not.\n\n        Returns\n        -------\n        trackall: bool\n            Whether the solver compute all residuals or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_73getTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTrackAll (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTrackAll", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTrackAll", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_72getTrackAll(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_72getTrackAll(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTrackAll", 0);

  /* "SLEPc/EPS.pyx":856
 *             Whether the solver compute all residuals or not.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetTrackAll(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":857
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSGetTrackAll(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetTrackAll(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 857, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":858
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSGetTrackAll(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setTrackAll(self, trackall):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 858, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":846
 *         CHKERR( EPSSetTrueResidual(self.eps, tval) )
 * 
 *     def getTrackAll(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether all residual norms must be
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getTrackAll", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":860
 *         return toBool(tval)
 * 
 *     def setTrackAll(self, trackall):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies if the solver must compute the residual of all
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_75setTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_74setTrackAll[] = "EPS.setTrackAll(self, trackall)\n\n        Specifies if the solver must compute the residual of all\n        approximate eigenpairs or not.\n\n        Parameters\n        ----------\n        trackall: bool\n            Whether compute all residuals or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_75setTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_trackall = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTrackAll (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_trackall,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_trackall)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTrackAll") < 0)) __PYX_ERR(17, 860, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_trackall = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTrackAll", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 860, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setTrackAll", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_74setTrackAll(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_trackall);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_74setTrackAll(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_trackall) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTrackAll", 0);

  /* "SLEPc/EPS.pyx":870
 *             Whether compute all residuals or not.
 *         """
 *         cdef PetscBool tval = asBool(trackall)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetTrackAll(self.eps, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_trackall); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 870, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/EPS.pyx":871
 *         """
 *         cdef PetscBool tval = asBool(trackall)
 *         CHKERR( EPSSetTrackAll(self.eps, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getDimensions(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetTrackAll(__pyx_v_self->eps, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 871, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":860
 *         return toBool(tval)
 * 
 *     def setTrackAll(self, trackall):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies if the solver must compute the residual of all
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setTrackAll", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":873
 *         CHKERR( EPSSetTrackAll(self.eps, tval) )
 * 
 *     def getDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of eigenvalues to compute and the dimension of
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_77getDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_76getDimensions[] = "EPS.getDimensions(self)\n\n        Gets the number of eigenvalues to compute and the dimension of\n        the subspace.\n\n        Returns\n        -------\n        nev: int\n             Number of eigenvalues to compute.\n        ncv: int\n             Maximum dimension of the subspace to be used by the\n             solver.\n        mpd: int\n             Maximum dimension allowed for the projected problem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_77getDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDimensions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getDimensions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDimensions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_76getDimensions(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_76getDimensions(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getDimensions", 0);

  /* "SLEPc/EPS.pyx":888
 *              Maximum dimension allowed for the projected problem.
 *         """
 *         cdef PetscInt ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/EPS.pyx":889
 *         """
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival3 = 0
 *         CHKERR( EPSGetDimensions(self.eps, &ival1, &ival2, &ival3) )
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/EPS.pyx":890
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetDimensions(self.eps, &ival1, &ival2, &ival3) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 */
  __pyx_v_ival3 = 0;

  /* "SLEPc/EPS.pyx":891
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 *         CHKERR( EPSGetDimensions(self.eps, &ival1, &ival2, &ival3) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetDimensions(__pyx_v_self->eps, (&__pyx_v_ival1), (&__pyx_v_ival2), (&__pyx_v_ival3))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 891, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":892
 *         cdef PetscInt ival3 = 0
 *         CHKERR( EPSGetDimensions(self.eps, &ival1, &ival2, &ival3) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))             # <<<<<<<<<<<<<<
 * 
 *     def setDimensions(self, nev=None, ncv=None, mpd=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 892, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 892, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival3); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 892, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(17, 892, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":873
 *         CHKERR( EPSSetTrackAll(self.eps, tval) )
 * 
 *     def getDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of eigenvalues to compute and the dimension of
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":894
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 *     def setDimensions(self, nev=None, ncv=None, mpd=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of eigenvalues to compute and the dimension of
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_79setDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_78setDimensions[] = "EPS.setDimensions(self, nev=None, ncv=None, mpd=None)\n\n        Sets the number of eigenvalues to compute and the dimension of\n        the subspace.\n\n        Parameters\n        ----------\n        nev: int, optional\n             Number of eigenvalues to compute.\n        ncv: int, optional\n             Maximum dimension of the subspace to be used by the\n             solver.\n        mpd: int, optional\n             Maximum dimension allowed for the projected problem.\n\n        Notes\n        -----\n        Use `DECIDE` for `ncv` and `mpd` to assign a reasonably good\n        value, which is dependent on the solution method.\n\n        The parameters `ncv` and `mpd` are intimately related, so that\n        the user is advised to set one of them at most. Normal usage\n        is the following:\n\n        + In cases where `nev` is small, the user sets `ncv`\n          (a reasonable default is 2 * `nev`).\n\n        + In cases where `nev` is large, the user sets `mpd`.\n\n        The value of `ncv` should always be between `nev` and (`nev` +\n        `mpd`), typically `ncv` = `nev` + `mpd`. If `nev` is not too\n        large, `mpd` = `nev` is a reasonable choice, otherwise a\n        smaller value should be used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_79setDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nev = 0;
  PyObject *__pyx_v_ncv = 0;
  PyObject *__pyx_v_mpd = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setDimensions (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nev,&__pyx_n_s_ncv,&__pyx_n_s_mpd,0};
    PyObject* values[3] = {0,0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nev);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ncv);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mpd);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setDimensions") < 0)) __PYX_ERR(17, 894, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_nev = values[0];
    __pyx_v_ncv = values[1];
    __pyx_v_mpd = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setDimensions", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 894, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_78setDimensions(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_nev, __pyx_v_ncv, __pyx_v_mpd);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_78setDimensions(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_nev, PyObject *__pyx_v_ncv, PyObject *__pyx_v_mpd) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setDimensions", 0);

  /* "SLEPc/EPS.pyx":928
 *         smaller value should be used.
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":929
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":930
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)
 */
  __pyx_v_ival3 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":931
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)             # <<<<<<<<<<<<<<
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)
 */
  __pyx_t_1 = (__pyx_v_nev != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_nev); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 931, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":932
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)             # <<<<<<<<<<<<<<
 *         if mpd is not None: ival3 = asInt(mpd)
 *         CHKERR( EPSSetDimensions(self.eps, ival1, ival2, ival3) )
 */
  __pyx_t_2 = (__pyx_v_ncv != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_ncv); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 932, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":933
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetDimensions(self.eps, ival1, ival2, ival3) )
 * 
 */
  __pyx_t_1 = (__pyx_v_mpd != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_mpd); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 933, __pyx_L1_error)
    __pyx_v_ival3 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":934
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)
 *         CHKERR( EPSSetDimensions(self.eps, ival1, ival2, ival3) )             # <<<<<<<<<<<<<<
 * 
 *     def getST(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetDimensions(__pyx_v_self->eps, __pyx_v_ival1, __pyx_v_ival2, __pyx_v_ival3)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(17, 934, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":894
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 *     def setDimensions(self, nev=None, ncv=None, mpd=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of eigenvalues to compute and the dimension of
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":936
 *         CHKERR( EPSSetDimensions(self.eps, ival1, ival2, ival3) )
 * 
 *     def getST(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the spectral transformation (`ST`) object associated to
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_81getST(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_80getST[] = "EPS.getST(self)\n\n        Obtain the spectral transformation (`ST`) object associated to\n        the eigensolver object.\n\n        Returns\n        -------\n        st: ST\n            The spectral transformation.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_81getST(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getST (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getST", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getST", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_80getST(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_80getST(struct PySlepcEPSObject *__pyx_v_self) {
  struct PySlepcSTObject *__pyx_v_st = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getST", 0);

  /* "SLEPc/EPS.pyx":946
 *             The spectral transformation.
 *         """
 *         cdef ST st = ST()             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetST(self.eps, &st.st) )
 *         PetscINCREF(st.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_ST)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 946, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_st = ((struct PySlepcSTObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":947
 *         """
 *         cdef ST st = ST()
 *         CHKERR( EPSGetST(self.eps, &st.st) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(st.obj)
 *         return st
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetST(__pyx_v_self->eps, (&__pyx_v_st->st))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 947, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":948
 *         cdef ST st = ST()
 *         CHKERR( EPSGetST(self.eps, &st.st) )
 *         PetscINCREF(st.obj)             # <<<<<<<<<<<<<<
 *         return st
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_st->__pyx_base.obj));

  /* "SLEPc/EPS.pyx":949
 *         CHKERR( EPSGetST(self.eps, &st.st) )
 *         PetscINCREF(st.obj)
 *         return st             # <<<<<<<<<<<<<<
 * 
 *     def setST(self, ST st):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_st));
  __pyx_r = ((PyObject *)__pyx_v_st);
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":936
 *         CHKERR( EPSSetDimensions(self.eps, ival1, ival2, ival3) )
 * 
 *     def getST(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the spectral transformation (`ST`) object associated to
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getST", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_st);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":951
 *         return st
 * 
 *     def setST(self, ST st):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a spectral transformation object to the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_83setST(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_82setST[] = "EPS.setST(self, ST st)\n\n        Associates a spectral transformation object to the\n        eigensolver.\n\n        Parameters\n        ----------\n        st: ST\n            The spectral transformation.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_83setST(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcSTObject *__pyx_v_st = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setST (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_st,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_st)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setST") < 0)) __PYX_ERR(17, 951, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_st = ((struct PySlepcSTObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setST", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 951, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setST", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_st), __pyx_ptype_8slepc4py_5SLEPc_ST, 0, "st", 0))) __PYX_ERR(17, 951, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_82setST(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_st);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_82setST(struct PySlepcEPSObject *__pyx_v_self, struct PySlepcSTObject *__pyx_v_st) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setST", 0);

  /* "SLEPc/EPS.pyx":961
 *             The spectral transformation.
 *         """
 *         CHKERR( EPSSetST(self.eps, st.st) )             # <<<<<<<<<<<<<<
 * 
 *     def getBV(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetST(__pyx_v_self->eps, __pyx_v_st->st)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 961, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":951
 *         return st
 * 
 *     def setST(self, ST st):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a spectral transformation object to the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setST", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":963
 *         CHKERR( EPSSetST(self.eps, st.st) )
 * 
 *     def getBV(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the basis vector objects associated to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_85getBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_84getBV[] = "EPS.getBV(self)\n\n        Obtain the basis vector objects associated to the eigensolver.\n\n        Returns\n        -------\n        bv: BV\n            The basis vectors context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_85getBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getBV (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getBV", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBV", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_84getBV(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_84getBV(struct PySlepcEPSObject *__pyx_v_self) {
  struct PySlepcBVObject *__pyx_v_bv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getBV", 0);

  /* "SLEPc/EPS.pyx":972
 *             The basis vectors context.
 *         """
 *         cdef BV bv = BV()             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetBV(self.eps, &bv.bv) )
 *         PetscINCREF(bv.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 972, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_bv = ((struct PySlepcBVObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":973
 *         """
 *         cdef BV bv = BV()
 *         CHKERR( EPSGetBV(self.eps, &bv.bv) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(bv.obj)
 *         return bv
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetBV(__pyx_v_self->eps, (&__pyx_v_bv->bv))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 973, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":974
 *         cdef BV bv = BV()
 *         CHKERR( EPSGetBV(self.eps, &bv.bv) )
 *         PetscINCREF(bv.obj)             # <<<<<<<<<<<<<<
 *         return bv
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_bv->__pyx_base.obj));

  /* "SLEPc/EPS.pyx":975
 *         CHKERR( EPSGetBV(self.eps, &bv.bv) )
 *         PetscINCREF(bv.obj)
 *         return bv             # <<<<<<<<<<<<<<
 * 
 *     def setBV(self, BV bv):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_bv));
  __pyx_r = ((PyObject *)__pyx_v_bv);
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":963
 *         CHKERR( EPSSetST(self.eps, st.st) )
 * 
 *     def getBV(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the basis vector objects associated to the eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_bv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":977
 *         return bv
 * 
 *     def setBV(self, BV bv):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a basis vectors object to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_87setBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_86setBV[] = "EPS.setBV(self, BV bv)\n\n        Associates a basis vectors object to the eigensolver.\n\n        Parameters\n        ----------\n        bv: BV\n            The basis vectors context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_87setBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcBVObject *__pyx_v_bv = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setBV (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bv,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bv)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setBV") < 0)) __PYX_ERR(17, 977, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_bv = ((struct PySlepcBVObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setBV", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 977, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_bv), __pyx_ptype_8slepc4py_5SLEPc_BV, 0, "bv", 0))) __PYX_ERR(17, 977, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_86setBV(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_bv);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_86setBV(struct PySlepcEPSObject *__pyx_v_self, struct PySlepcBVObject *__pyx_v_bv) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setBV", 0);

  /* "SLEPc/EPS.pyx":986
 *             The basis vectors context.
 *         """
 *         CHKERR( EPSSetBV(self.eps, bv.bv) )             # <<<<<<<<<<<<<<
 * 
 *     def getDS(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetBV(__pyx_v_self->eps, __pyx_v_bv->bv)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 986, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":977
 *         return bv
 * 
 *     def setBV(self, BV bv):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a basis vectors object to the eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":988
 *         CHKERR( EPSSetBV(self.eps, bv.bv) )
 * 
 *     def getDS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the direct solver associated to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_89getDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_88getDS[] = "EPS.getDS(self)\n\n        Obtain the direct solver associated to the eigensolver.\n\n        Returns\n        -------\n        ds: DS\n            The direct solver context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_89getDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDS (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getDS", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDS", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_88getDS(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_88getDS(struct PySlepcEPSObject *__pyx_v_self) {
  struct PySlepcDSObject *__pyx_v_ds = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getDS", 0);

  /* "SLEPc/EPS.pyx":997
 *             The direct solver context.
 *         """
 *         cdef DS ds = DS()             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetDS(self.eps, &ds.ds) )
 *         PetscINCREF(ds.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_DS)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 997, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ds = ((struct PySlepcDSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":998
 *         """
 *         cdef DS ds = DS()
 *         CHKERR( EPSGetDS(self.eps, &ds.ds) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(ds.obj)
 *         return ds
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetDS(__pyx_v_self->eps, (&__pyx_v_ds->ds))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 998, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":999
 *         cdef DS ds = DS()
 *         CHKERR( EPSGetDS(self.eps, &ds.ds) )
 *         PetscINCREF(ds.obj)             # <<<<<<<<<<<<<<
 *         return ds
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ds->__pyx_base.obj));

  /* "SLEPc/EPS.pyx":1000
 *         CHKERR( EPSGetDS(self.eps, &ds.ds) )
 *         PetscINCREF(ds.obj)
 *         return ds             # <<<<<<<<<<<<<<
 * 
 *     def setDS(self, DS ds):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ds));
  __pyx_r = ((PyObject *)__pyx_v_ds);
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":988
 *         CHKERR( EPSSetBV(self.eps, bv.bv) )
 * 
 *     def getDS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the direct solver associated to the eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ds);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1002
 *         return ds
 * 
 *     def setDS(self, DS ds):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a direct solver object to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_91setDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_90setDS[] = "EPS.setDS(self, DS ds)\n\n        Associates a direct solver object to the eigensolver.\n\n        Parameters\n        ----------\n        ds: DS\n            The direct solver context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_91setDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcDSObject *__pyx_v_ds = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setDS (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ds,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ds)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setDS") < 0)) __PYX_ERR(17, 1002, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_ds = ((struct PySlepcDSObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setDS", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1002, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ds), __pyx_ptype_8slepc4py_5SLEPc_DS, 0, "ds", 0))) __PYX_ERR(17, 1002, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_90setDS(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_ds);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_90setDS(struct PySlepcEPSObject *__pyx_v_self, struct PySlepcDSObject *__pyx_v_ds) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setDS", 0);

  /* "SLEPc/EPS.pyx":1011
 *             The direct solver context.
 *         """
 *         CHKERR( EPSSetDS(self.eps, ds.ds) )             # <<<<<<<<<<<<<<
 * 
 *     def getRG(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetDS(__pyx_v_self->eps, __pyx_v_ds->ds)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1011, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1002
 *         return ds
 * 
 *     def setDS(self, DS ds):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a direct solver object to the eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1013
 *         CHKERR( EPSSetDS(self.eps, ds.ds) )
 * 
 *     def getRG(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the region object associated to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_93getRG(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_92getRG[] = "EPS.getRG(self)\n\n        Obtain the region object associated to the eigensolver.\n\n        Returns\n        -------\n        rg: RG\n            The region context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_93getRG(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRG (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRG", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRG", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_92getRG(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_92getRG(struct PySlepcEPSObject *__pyx_v_self) {
  struct PySlepcRGObject *__pyx_v_rg = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRG", 0);

  /* "SLEPc/EPS.pyx":1022
 *             The region context.
 *         """
 *         cdef RG rg = RG()             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetRG(self.eps, &rg.rg) )
 *         PetscINCREF(rg.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_RG)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1022, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_rg = ((struct PySlepcRGObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":1023
 *         """
 *         cdef RG rg = RG()
 *         CHKERR( EPSGetRG(self.eps, &rg.rg) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(rg.obj)
 *         return rg
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetRG(__pyx_v_self->eps, (&__pyx_v_rg->rg))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1023, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1024
 *         cdef RG rg = RG()
 *         CHKERR( EPSGetRG(self.eps, &rg.rg) )
 *         PetscINCREF(rg.obj)             # <<<<<<<<<<<<<<
 *         return rg
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_rg->__pyx_base.obj));

  /* "SLEPc/EPS.pyx":1025
 *         CHKERR( EPSGetRG(self.eps, &rg.rg) )
 *         PetscINCREF(rg.obj)
 *         return rg             # <<<<<<<<<<<<<<
 * 
 *     def setRG(self, RG rg):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_rg));
  __pyx_r = ((PyObject *)__pyx_v_rg);
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1013
 *         CHKERR( EPSSetDS(self.eps, ds.ds) )
 * 
 *     def getRG(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the region object associated to the eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getRG", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_rg);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1027
 *         return rg
 * 
 *     def setRG(self, RG rg):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a region object to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_95setRG(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_94setRG[] = "EPS.setRG(self, RG rg)\n\n        Associates a region object to the eigensolver.\n\n        Parameters\n        ----------\n        rg: RG\n            The region context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_95setRG(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcRGObject *__pyx_v_rg = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRG (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rg,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rg)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRG") < 0)) __PYX_ERR(17, 1027, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_rg = ((struct PySlepcRGObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRG", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1027, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setRG", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rg), __pyx_ptype_8slepc4py_5SLEPc_RG, 0, "rg", 0))) __PYX_ERR(17, 1027, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_94setRG(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_rg);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_94setRG(struct PySlepcEPSObject *__pyx_v_self, struct PySlepcRGObject *__pyx_v_rg) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRG", 0);

  /* "SLEPc/EPS.pyx":1036
 *             The region context.
 *         """
 *         CHKERR( EPSSetRG(self.eps, rg.rg) )             # <<<<<<<<<<<<<<
 * 
 *     def getOperators(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetRG(__pyx_v_self->eps, __pyx_v_rg->rg)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1036, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1027
 *         return rg
 * 
 *     def setRG(self, RG rg):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a region object to the eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setRG", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1038
 *         CHKERR( EPSSetRG(self.eps, rg.rg) )
 * 
 *     def getOperators(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the matrices associated with the eigenvalue problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_97getOperators(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_96getOperators[] = "EPS.getOperators(self)\n\n        Gets the matrices associated with the eigenvalue problem.\n\n        Returns\n        -------\n        A: Mat\n           The matrix associated with the eigensystem.\n        B: Mat\n           The second matrix in the case of generalized eigenproblems.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_97getOperators(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOperators (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOperators", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOperators", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_96getOperators(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_96getOperators(struct PySlepcEPSObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  struct PyPetscMatObject *__pyx_v_B = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOperators", 0);

  /* "SLEPc/EPS.pyx":1049
 *            The second matrix in the case of generalized eigenproblems.
 *         """
 *         cdef Mat A = Mat()             # <<<<<<<<<<<<<<
 *         cdef Mat B = Mat()
 *         CHKERR( EPSGetOperators(self.eps, &A.mat, &B.mat) )
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1049, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_A = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":1050
 *         """
 *         cdef Mat A = Mat()
 *         cdef Mat B = Mat()             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetOperators(self.eps, &A.mat, &B.mat) )
 *         PetscINCREF(A.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1050, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_B = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":1051
 *         cdef Mat A = Mat()
 *         cdef Mat B = Mat()
 *         CHKERR( EPSGetOperators(self.eps, &A.mat, &B.mat) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(A.obj)
 *         if B.mat:
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetOperators(__pyx_v_self->eps, (&__pyx_v_A->mat), (&__pyx_v_B->mat))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1051, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1052
 *         cdef Mat B = Mat()
 *         CHKERR( EPSGetOperators(self.eps, &A.mat, &B.mat) )
 *         PetscINCREF(A.obj)             # <<<<<<<<<<<<<<
 *         if B.mat:
 *             PetscINCREF(B.obj)
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_A->__pyx_base.obj));

  /* "SLEPc/EPS.pyx":1053
 *         CHKERR( EPSGetOperators(self.eps, &A.mat, &B.mat) )
 *         PetscINCREF(A.obj)
 *         if B.mat:             # <<<<<<<<<<<<<<
 *             PetscINCREF(B.obj)
 *             return (A, B)
 */
  __pyx_t_3 = (__pyx_v_B->mat != 0);
  if (__pyx_t_3) {

    /* "SLEPc/EPS.pyx":1054
 *         PetscINCREF(A.obj)
 *         if B.mat:
 *             PetscINCREF(B.obj)             # <<<<<<<<<<<<<<
 *             return (A, B)
 *         else:
 */
    (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_B->__pyx_base.obj));

    /* "SLEPc/EPS.pyx":1055
 *         if B.mat:
 *             PetscINCREF(B.obj)
 *             return (A, B)             # <<<<<<<<<<<<<<
 *         else:
 *             return (A, None)
 */
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1055, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_INCREF(((PyObject *)__pyx_v_A));
    __Pyx_GIVEREF(((PyObject *)__pyx_v_A));
    PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_A));
    __Pyx_INCREF(((PyObject *)__pyx_v_B));
    __Pyx_GIVEREF(((PyObject *)__pyx_v_B));
    PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_B));
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;

    /* "SLEPc/EPS.pyx":1053
 *         CHKERR( EPSGetOperators(self.eps, &A.mat, &B.mat) )
 *         PetscINCREF(A.obj)
 *         if B.mat:             # <<<<<<<<<<<<<<
 *             PetscINCREF(B.obj)
 *             return (A, B)
 */
  }

  /* "SLEPc/EPS.pyx":1057
 *             return (A, B)
 *         else:
 *             return (A, None)             # <<<<<<<<<<<<<<
 * 
 *     def setOperators(self, Mat A, Mat B=None):
 */
  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1057, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_INCREF(((PyObject *)__pyx_v_A));
    __Pyx_GIVEREF(((PyObject *)__pyx_v_A));
    PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_A));
    __Pyx_INCREF(Py_None);
    __Pyx_GIVEREF(Py_None);
    PyTuple_SET_ITEM(__pyx_t_1, 1, Py_None);
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;
  }

  /* "SLEPc/EPS.pyx":1038
 *         CHKERR( EPSSetRG(self.eps, rg.rg) )
 * 
 *     def getOperators(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the matrices associated with the eigenvalue problem.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getOperators", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_A);
  __Pyx_XDECREF((PyObject *)__pyx_v_B);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1059
 *             return (A, None)
 * 
 *     def setOperators(self, Mat A, Mat B=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the matrices associated with the eigenvalue problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_99setOperators(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_98setOperators[] = "EPS.setOperators(self, Mat A, Mat B=None)\n\n        Sets the matrices associated with the eigenvalue problem.\n\n        Parameters\n        ----------\n        A: Mat\n           The matrix associated with the eigensystem.\n        B: Mat, optional\n           The second matrix in the case of generalized eigenproblems;\n           if not provided, a standard eigenproblem is assumed.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_99setOperators(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  struct PyPetscMatObject *__pyx_v_B = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOperators (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_A,&__pyx_n_s_B,0};
    PyObject* values[2] = {0,0};
    values[1] = (PyObject *)((struct PyPetscMatObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_A)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_B);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOperators") < 0)) __PYX_ERR(17, 1059, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_A = ((struct PyPetscMatObject *)values[0]);
    __pyx_v_B = ((struct PyPetscMatObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOperators", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1059, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setOperators", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_A), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "A", 0))) __PYX_ERR(17, 1059, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_B), __pyx_ptype_8petsc4py_5PETSc_Mat, 1, "B", 0))) __PYX_ERR(17, 1059, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_98setOperators(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_A, __pyx_v_B);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_98setOperators(struct PySlepcEPSObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, struct PyPetscMatObject *__pyx_v_B) {
  Mat __pyx_v_Bmat;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Mat __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOperators", 0);

  /* "SLEPc/EPS.pyx":1071
 *            if not provided, a standard eigenproblem is assumed.
 *         """
 *         cdef PetscMat Bmat = B.mat if B is not None else <PetscMat>NULL             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetOperators(self.eps, A.mat, Bmat) )
 * 
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_B) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_B->mat;
  } else {
    __pyx_t_1 = ((Mat)NULL);
  }
  __pyx_v_Bmat = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1072
 *         """
 *         cdef PetscMat Bmat = B.mat if B is not None else <PetscMat>NULL
 *         CHKERR( EPSSetOperators(self.eps, A.mat, Bmat) )             # <<<<<<<<<<<<<<
 * 
 *     def setDeflationSpace(self, space):
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetOperators(__pyx_v_self->eps, __pyx_v_A->mat, __pyx_v_Bmat)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(17, 1072, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1059
 *             return (A, None)
 * 
 *     def setOperators(self, Mat A, Mat B=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the matrices associated with the eigenvalue problem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setOperators", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1074
 *         CHKERR( EPSSetOperators(self.eps, A.mat, Bmat) )
 * 
 *     def setDeflationSpace(self, space):             # <<<<<<<<<<<<<<
 *         """
 *         Add vectors to the basis of the deflation space.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_101setDeflationSpace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_100setDeflationSpace[] = "EPS.setDeflationSpace(self, space)\n\n        Add vectors to the basis of the deflation space.\n\n        Parameters\n        ----------\n        space: a Vec or an array of Vec\n               Set of basis vectors to be added to the deflation\n               space.\n\n        Notes\n        -----\n        When a deflation space is given, the eigensolver seeks the\n        eigensolution in the restriction of the problem to the\n        orthogonal complement of this space. This can be used for\n        instance in the case that an invariant subspace is known\n        beforehand (such as the nullspace of the matrix).\n\n        The vectors do not need to be mutually orthonormal, since they\n        are explicitly orthonormalized internally.\n\n        These vectors do not persist from one `solve()` call to the other,\n        so the deflation space should be set every time.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_101setDeflationSpace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_space = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setDeflationSpace (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_space,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_space)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setDeflationSpace") < 0)) __PYX_ERR(17, 1074, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_space = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setDeflationSpace", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1074, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setDeflationSpace", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_100setDeflationSpace(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_space);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_100setDeflationSpace(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_space) {
  Vec *__pyx_v_vs;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_ns;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  Py_ssize_t __pyx_t_6;
  Vec __pyx_t_7;
  int __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setDeflationSpace", 0);
  __Pyx_INCREF(__pyx_v_space);

  /* "SLEPc/EPS.pyx":1098
 *         so the deflation space should be set every time.
 *         """
 *         if isinstance(space, Vec): space = [space]             # <<<<<<<<<<<<<<
 *         cdef PetscVec* vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)
 */
  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_space, __pyx_ptype_8petsc4py_5PETSc_Vec); 
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1098, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_space);
    __Pyx_GIVEREF(__pyx_v_space);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_space);
    __Pyx_DECREF_SET(__pyx_v_space, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/EPS.pyx":1099
 *         """
 *         if isinstance(space, Vec): space = [space]
 *         cdef PetscVec* vs = NULL             # <<<<<<<<<<<<<<
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 */
  __pyx_v_vs = NULL;

  /* "SLEPc/EPS.pyx":1100
 *         if isinstance(space, Vec): space = [space]
 *         cdef PetscVec* vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)             # <<<<<<<<<<<<<<
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 */
  __pyx_v_i = 0;
  __pyx_t_4 = PyObject_Length(__pyx_v_space); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(17, 1100, __pyx_L1_error)
  __pyx_v_ns = __pyx_t_4;

  /* "SLEPc/EPS.pyx":1101
 *         cdef PetscVec* vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)             # <<<<<<<<<<<<<<
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 *         CHKERR( EPSSetDeflationSpace(self.eps, <PetscInt>ns, vs) )
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_ns) * (sizeof(Vec))), ((void **)(&__pyx_v_vs))); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1101, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/EPS.pyx":1102
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetDeflationSpace(self.eps, <PetscInt>ns, vs) )
 * 
 */
  __pyx_t_4 = __pyx_v_ns;
  __pyx_t_5 = __pyx_t_4;
  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
    __pyx_v_i = __pyx_t_6;
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_space, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1102, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8petsc4py_5PETSc_Vec)))) __PYX_ERR(17, 1102, __pyx_L1_error)
    __pyx_t_7 = ((struct PyPetscVecObject *)__pyx_t_3)->vec;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    (__pyx_v_vs[__pyx_v_i]) = __pyx_t_7;
  }

  /* "SLEPc/EPS.pyx":1103
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 *         CHKERR( EPSSetDeflationSpace(self.eps, <PetscInt>ns, vs) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_8 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetDeflationSpace(__pyx_v_self->eps, ((PetscInt)__pyx_v_ns), __pyx_v_vs)); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(17, 1103, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1074
 *         CHKERR( EPSSetOperators(self.eps, A.mat, Bmat) )
 * 
 *     def setDeflationSpace(self, space):             # <<<<<<<<<<<<<<
 *         """
 *         Add vectors to the basis of the deflation space.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setDeflationSpace", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XDECREF(__pyx_v_space);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1107
 *     #
 * 
 *     def setInitialSpace(self, space):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the initial space from which the eigensolver starts to
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_103setInitialSpace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_102setInitialSpace[] = "EPS.setInitialSpace(self, space)\n\n        Sets the initial space from which the eigensolver starts to\n        iterate.\n\n        Parameters\n        ----------\n        space: Vec or sequence of Vec\n           The initial space\n\n        Notes\n        -----\n        Some solvers start to iterate on a single vector (initial vector).\n        In that case, the other vectors are ignored.\n\n        In contrast to `setDeflationSpace()`, these vectors do not persist\n        from one `solve()` call to the other, so the initial space should be\n        set every time.\n\n        The vectors do not need to be mutually orthonormal, since they are\n        explicitly orthonormalized internally.\n\n        Common usage of this function is when the user can provide a rough\n        approximation of the wanted eigenspace. Then, convergence may be faster.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_103setInitialSpace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_space = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setInitialSpace (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_space,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_space)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setInitialSpace") < 0)) __PYX_ERR(17, 1107, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_space = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setInitialSpace", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1107, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setInitialSpace", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_102setInitialSpace(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_space);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_102setInitialSpace(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_space) {
  Vec *__pyx_v_vs;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_ns;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  Py_ssize_t __pyx_t_6;
  Vec __pyx_t_7;
  int __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setInitialSpace", 0);
  __Pyx_INCREF(__pyx_v_space);

  /* "SLEPc/EPS.pyx":1132
 *         approximation of the wanted eigenspace. Then, convergence may be faster.
 *         """
 *         if isinstance(space, Vec): space = [space]             # <<<<<<<<<<<<<<
 *         cdef PetscVec *vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)
 */
  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_space, __pyx_ptype_8petsc4py_5PETSc_Vec); 
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1132, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_space);
    __Pyx_GIVEREF(__pyx_v_space);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_space);
    __Pyx_DECREF_SET(__pyx_v_space, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/EPS.pyx":1133
 *         """
 *         if isinstance(space, Vec): space = [space]
 *         cdef PetscVec *vs = NULL             # <<<<<<<<<<<<<<
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 */
  __pyx_v_vs = NULL;

  /* "SLEPc/EPS.pyx":1134
 *         if isinstance(space, Vec): space = [space]
 *         cdef PetscVec *vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)             # <<<<<<<<<<<<<<
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 */
  __pyx_v_i = 0;
  __pyx_t_4 = PyObject_Length(__pyx_v_space); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(17, 1134, __pyx_L1_error)
  __pyx_v_ns = __pyx_t_4;

  /* "SLEPc/EPS.pyx":1135
 *         cdef PetscVec *vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)             # <<<<<<<<<<<<<<
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 *         CHKERR( EPSSetInitialSpace(self.eps, <PetscInt>ns, vs) )
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_ns) * (sizeof(Vec))), ((void **)(&__pyx_v_vs))); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1135, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/EPS.pyx":1136
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetInitialSpace(self.eps, <PetscInt>ns, vs) )
 * 
 */
  __pyx_t_4 = __pyx_v_ns;
  __pyx_t_5 = __pyx_t_4;
  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
    __pyx_v_i = __pyx_t_6;
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_space, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1136, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8petsc4py_5PETSc_Vec)))) __PYX_ERR(17, 1136, __pyx_L1_error)
    __pyx_t_7 = ((struct PyPetscVecObject *)__pyx_t_3)->vec;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    (__pyx_v_vs[__pyx_v_i]) = __pyx_t_7;
  }

  /* "SLEPc/EPS.pyx":1137
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 *         CHKERR( EPSSetInitialSpace(self.eps, <PetscInt>ns, vs) )             # <<<<<<<<<<<<<<
 * 
 *     def setLeftInitialSpace(self, space):
 */
  __pyx_t_8 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetInitialSpace(__pyx_v_self->eps, ((PetscInt)__pyx_v_ns), __pyx_v_vs)); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(17, 1137, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1107
 *     #
 * 
 *     def setInitialSpace(self, space):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the initial space from which the eigensolver starts to
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setInitialSpace", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XDECREF(__pyx_v_space);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1139
 *         CHKERR( EPSSetInitialSpace(self.eps, <PetscInt>ns, vs) )
 * 
 *     def setLeftInitialSpace(self, space):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the left initial space from which the eigensolver starts to
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_105setLeftInitialSpace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_104setLeftInitialSpace[] = "EPS.setLeftInitialSpace(self, space)\n\n        Sets the left initial space from which the eigensolver starts to\n        iterate.\n\n        Parameters\n        ----------\n        space: Vec or sequence of Vec\n           The left initial space\n\n        Notes\n        -----\n        Left initial vectors are used to initiate the left search space\n        in two-sided eigensolvers. Users should pass here an approximation\n        of the left eigenspace, if available.\n\n        The same comments in `setInitialSpace()` are applicable here.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_105setLeftInitialSpace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_space = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setLeftInitialSpace (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_space,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_space)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setLeftInitialSpace") < 0)) __PYX_ERR(17, 1139, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_space = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setLeftInitialSpace", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1139, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setLeftInitialSpace", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_104setLeftInitialSpace(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_space);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_104setLeftInitialSpace(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_space) {
  Vec *__pyx_v_vs;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_ns;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  Py_ssize_t __pyx_t_6;
  Vec __pyx_t_7;
  int __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setLeftInitialSpace", 0);
  __Pyx_INCREF(__pyx_v_space);

  /* "SLEPc/EPS.pyx":1157
 *         The same comments in `setInitialSpace()` are applicable here.
 *         """
 *         if isinstance(space, Vec): space = [space]             # <<<<<<<<<<<<<<
 *         cdef PetscVec *vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)
 */
  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_space, __pyx_ptype_8petsc4py_5PETSc_Vec); 
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1157, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_space);
    __Pyx_GIVEREF(__pyx_v_space);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_space);
    __Pyx_DECREF_SET(__pyx_v_space, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/EPS.pyx":1158
 *         """
 *         if isinstance(space, Vec): space = [space]
 *         cdef PetscVec *vs = NULL             # <<<<<<<<<<<<<<
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 */
  __pyx_v_vs = NULL;

  /* "SLEPc/EPS.pyx":1159
 *         if isinstance(space, Vec): space = [space]
 *         cdef PetscVec *vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)             # <<<<<<<<<<<<<<
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 */
  __pyx_v_i = 0;
  __pyx_t_4 = PyObject_Length(__pyx_v_space); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(17, 1159, __pyx_L1_error)
  __pyx_v_ns = __pyx_t_4;

  /* "SLEPc/EPS.pyx":1160
 *         cdef PetscVec *vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)             # <<<<<<<<<<<<<<
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 *         CHKERR( EPSSetLeftInitialSpace(self.eps, <PetscInt>ns, vs) )
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_ns) * (sizeof(Vec))), ((void **)(&__pyx_v_vs))); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/EPS.pyx":1161
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec             # <<<<<<<<<<<<<<
 *         CHKERR( EPSSetLeftInitialSpace(self.eps, <PetscInt>ns, vs) )
 * 
 */
  __pyx_t_4 = __pyx_v_ns;
  __pyx_t_5 = __pyx_t_4;
  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
    __pyx_v_i = __pyx_t_6;
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_space, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1161, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8petsc4py_5PETSc_Vec)))) __PYX_ERR(17, 1161, __pyx_L1_error)
    __pyx_t_7 = ((struct PyPetscVecObject *)__pyx_t_3)->vec;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    (__pyx_v_vs[__pyx_v_i]) = __pyx_t_7;
  }

  /* "SLEPc/EPS.pyx":1162
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 *         CHKERR( EPSSetLeftInitialSpace(self.eps, <PetscInt>ns, vs) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_8 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetLeftInitialSpace(__pyx_v_self->eps, ((PetscInt)__pyx_v_ns), __pyx_v_vs)); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(17, 1162, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1139
 *         CHKERR( EPSSetInitialSpace(self.eps, <PetscInt>ns, vs) )
 * 
 *     def setLeftInitialSpace(self, space):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the left initial space from which the eigensolver starts to
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setLeftInitialSpace", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XDECREF(__pyx_v_space);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1166
 *     #
 * 
 *     def setStoppingTest(self, stopping, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_107setStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_106setStoppingTest[] = "EPS.setStoppingTest(self, stopping, args=None, kargs=None)\n\n        Sets a function to decide when to stop the outer iteration of the eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_107setStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_stopping = 0;
  PyObject *__pyx_v_args = 0;
  PyObject *__pyx_v_kargs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setStoppingTest (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_stopping,&__pyx_n_s_args,&__pyx_n_s_kargs,0};
    PyObject* values[3] = {0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_stopping)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kargs);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setStoppingTest") < 0)) __PYX_ERR(17, 1166, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_stopping = values[0];
    __pyx_v_args = values[1];
    __pyx_v_kargs = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setStoppingTest", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1166, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setStoppingTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_106setStoppingTest(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_stopping, __pyx_v_args, __pyx_v_kargs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_106setStoppingTest(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_stopping, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setStoppingTest", 0);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);

  /* "SLEPc/EPS.pyx":1170
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 *         """
 *         if stopping is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
  __pyx_t_1 = (__pyx_v_stopping != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "SLEPc/EPS.pyx":1171
 *         """
 *         if stopping is not None:
 *             if args is None: args = ()             # <<<<<<<<<<<<<<
 *             if kargs is None: kargs = {}
 *             self.set_attr('__stopping__', (stopping, args, kargs))
 */
    __pyx_t_2 = (__pyx_v_args == Py_None);
    __pyx_t_1 = (__pyx_t_2 != 0);
    if (__pyx_t_1) {
      __Pyx_INCREF(__pyx_empty_tuple);
      __Pyx_DECREF_SET(__pyx_v_args, __pyx_empty_tuple);
    }

    /* "SLEPc/EPS.pyx":1172
 *         if stopping is not None:
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}             # <<<<<<<<<<<<<<
 *             self.set_attr('__stopping__', (stopping, args, kargs))
 *             CHKERR( EPSSetStoppingTestFunction(self.eps, EPS_Stopping, NULL, NULL) )
 */
    __pyx_t_1 = (__pyx_v_kargs == Py_None);
    __pyx_t_2 = (__pyx_t_1 != 0);
    if (__pyx_t_2) {
      __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1172, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF_SET(__pyx_v_kargs, __pyx_t_3);
      __pyx_t_3 = 0;
    }

    /* "SLEPc/EPS.pyx":1173
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 *             self.set_attr('__stopping__', (stopping, args, kargs))             # <<<<<<<<<<<<<<
 *             CHKERR( EPSSetStoppingTestFunction(self.eps, EPS_Stopping, NULL, NULL) )
 *         else:
 */
    __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1173, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_stopping);
    __Pyx_GIVEREF(__pyx_v_stopping);
    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_stopping);
    __Pyx_INCREF(__pyx_v_args);
    __Pyx_GIVEREF(__pyx_v_args);
    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_args);
    __Pyx_INCREF(__pyx_v_kargs);
    __Pyx_GIVEREF(__pyx_v_kargs);
    PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_kargs);
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__stopping__"), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 1173, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "SLEPc/EPS.pyx":1174
 *             if kargs is None: kargs = {}
 *             self.set_attr('__stopping__', (stopping, args, kargs))
 *             CHKERR( EPSSetStoppingTestFunction(self.eps, EPS_Stopping, NULL, NULL) )             # <<<<<<<<<<<<<<
 *         else:
 *             self.set_attr('__stopping__', None)
 */
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetStoppingTestFunction(__pyx_v_self->eps, __pyx_f_8slepc4py_5SLEPc_EPS_Stopping, NULL, NULL)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(17, 1174, __pyx_L1_error)

    /* "SLEPc/EPS.pyx":1170
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 *         """
 *         if stopping is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
    goto __pyx_L3;
  }

  /* "SLEPc/EPS.pyx":1176
 *             CHKERR( EPSSetStoppingTestFunction(self.eps, EPS_Stopping, NULL, NULL) )
 *         else:
 *             self.set_attr('__stopping__', None)             # <<<<<<<<<<<<<<
 *             CHKERR( EPSSetStoppingTestFunction(self.eps, EPSStoppingBasic, NULL, NULL) )
 * 
 */
  /*else*/ {
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__stopping__"), Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 1176, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "SLEPc/EPS.pyx":1177
 *         else:
 *             self.set_attr('__stopping__', None)
 *             CHKERR( EPSSetStoppingTestFunction(self.eps, EPSStoppingBasic, NULL, NULL) )             # <<<<<<<<<<<<<<
 * 
 *     def getStoppingTest(self):
 */
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetStoppingTestFunction(__pyx_v_self->eps, EPSStoppingBasic, NULL, NULL)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(17, 1177, __pyx_L1_error)
  }
  __pyx_L3:;

  /* "SLEPc/EPS.pyx":1166
 *     #
 * 
 *     def setStoppingTest(self, stopping, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setStoppingTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1179
 *             CHKERR( EPSSetStoppingTestFunction(self.eps, EPSStoppingBasic, NULL, NULL) )
 * 
 *     def getStoppingTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the stopping function.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_109getStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_108getStoppingTest[] = "EPS.getStoppingTest(self)\n\n        Gets the stopping function.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_109getStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getStoppingTest (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getStoppingTest", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getStoppingTest", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_108getStoppingTest(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_108getStoppingTest(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getStoppingTest", 0);

  /* "SLEPc/EPS.pyx":1183
 *         Gets the stopping function.
 *         """
 *         return self.get_attr('__stopping__')             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__stopping__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1179
 *             CHKERR( EPSSetStoppingTestFunction(self.eps, EPSStoppingBasic, NULL, NULL) )
 * 
 *     def getStoppingTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the stopping function.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getStoppingTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1187
 *     #
 * 
 *     def setArbitrarySelection(self, arbitrary, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a function to look for eigenvalues according to an arbitrary selection
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_111setArbitrarySelection(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_110setArbitrarySelection[] = "EPS.setArbitrarySelection(self, arbitrary, args=None, kargs=None)\n\n        Sets a function to look for eigenvalues according to an arbitrary selection\n        criterion. This criterion can be based on a computation involving the current\n        eigenvector approximation.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_111setArbitrarySelection(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_arbitrary = 0;
  PyObject *__pyx_v_args = 0;
  PyObject *__pyx_v_kargs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setArbitrarySelection (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_arbitrary,&__pyx_n_s_args,&__pyx_n_s_kargs,0};
    PyObject* values[3] = {0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arbitrary)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kargs);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setArbitrarySelection") < 0)) __PYX_ERR(17, 1187, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_arbitrary = values[0];
    __pyx_v_args = values[1];
    __pyx_v_kargs = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setArbitrarySelection", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1187, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setArbitrarySelection", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_110setArbitrarySelection(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_arbitrary, __pyx_v_args, __pyx_v_kargs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_110setArbitrarySelection(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_arbitrary, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs) {
  PyObject *__pyx_v_ctx = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setArbitrarySelection", 0);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);

  /* "SLEPc/EPS.pyx":1193
 *         eigenvector approximation.
 *         """
 *         if arbitrary is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
  __pyx_t_1 = (__pyx_v_arbitrary != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "SLEPc/EPS.pyx":1194
 *         """
 *         if arbitrary is not None:
 *             if args is None: args = ()             # <<<<<<<<<<<<<<
 *             if kargs is None: kargs = {}
 *             self.set_attr('__arbitrary__', (arbitrary, args, kargs))
 */
    __pyx_t_2 = (__pyx_v_args == Py_None);
    __pyx_t_1 = (__pyx_t_2 != 0);
    if (__pyx_t_1) {
      __Pyx_INCREF(__pyx_empty_tuple);
      __Pyx_DECREF_SET(__pyx_v_args, __pyx_empty_tuple);
    }

    /* "SLEPc/EPS.pyx":1195
 *         if arbitrary is not None:
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}             # <<<<<<<<<<<<<<
 *             self.set_attr('__arbitrary__', (arbitrary, args, kargs))
 *             ctx = self.get_attr('__arbitrary__')
 */
    __pyx_t_1 = (__pyx_v_kargs == Py_None);
    __pyx_t_2 = (__pyx_t_1 != 0);
    if (__pyx_t_2) {
      __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1195, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF_SET(__pyx_v_kargs, __pyx_t_3);
      __pyx_t_3 = 0;
    }

    /* "SLEPc/EPS.pyx":1196
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 *             self.set_attr('__arbitrary__', (arbitrary, args, kargs))             # <<<<<<<<<<<<<<
 *             ctx = self.get_attr('__arbitrary__')
 *             CHKERR( EPSSetArbitrarySelection(self.eps, EPS_Arbitrary, <void*>ctx) )
 */
    __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1196, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_arbitrary);
    __Pyx_GIVEREF(__pyx_v_arbitrary);
    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_arbitrary);
    __Pyx_INCREF(__pyx_v_args);
    __Pyx_GIVEREF(__pyx_v_args);
    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_args);
    __Pyx_INCREF(__pyx_v_kargs);
    __Pyx_GIVEREF(__pyx_v_kargs);
    PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_kargs);
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__arbitrary__"), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 1196, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "SLEPc/EPS.pyx":1197
 *             if kargs is None: kargs = {}
 *             self.set_attr('__arbitrary__', (arbitrary, args, kargs))
 *             ctx = self.get_attr('__arbitrary__')             # <<<<<<<<<<<<<<
 *             CHKERR( EPSSetArbitrarySelection(self.eps, EPS_Arbitrary, <void*>ctx) )
 *         else:
 */
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__arbitrary__")); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 1197, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_v_ctx = __pyx_t_4;
    __pyx_t_4 = 0;

    /* "SLEPc/EPS.pyx":1198
 *             self.set_attr('__arbitrary__', (arbitrary, args, kargs))
 *             ctx = self.get_attr('__arbitrary__')
 *             CHKERR( EPSSetArbitrarySelection(self.eps, EPS_Arbitrary, <void*>ctx) )             # <<<<<<<<<<<<<<
 *         else:
 *             self.set_attr('__arbitrary__', None)
 */
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetArbitrarySelection(__pyx_v_self->eps, __pyx_f_8slepc4py_5SLEPc_EPS_Arbitrary, ((void *)__pyx_v_ctx))); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(17, 1198, __pyx_L1_error)

    /* "SLEPc/EPS.pyx":1193
 *         eigenvector approximation.
 *         """
 *         if arbitrary is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
    goto __pyx_L3;
  }

  /* "SLEPc/EPS.pyx":1200
 *             CHKERR( EPSSetArbitrarySelection(self.eps, EPS_Arbitrary, <void*>ctx) )
 *         else:
 *             self.set_attr('__arbitrary__', None)             # <<<<<<<<<<<<<<
 *             CHKERR( EPSSetArbitrarySelection(self.eps, NULL, NULL) )
 * 
 */
  /*else*/ {
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__arbitrary__"), Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 1200, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "SLEPc/EPS.pyx":1201
 *         else:
 *             self.set_attr('__arbitrary__', None)
 *             CHKERR( EPSSetArbitrarySelection(self.eps, NULL, NULL) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetArbitrarySelection(__pyx_v_self->eps, NULL, NULL)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(17, 1201, __pyx_L1_error)
  }
  __pyx_L3:;

  /* "SLEPc/EPS.pyx":1187
 *     #
 * 
 *     def setArbitrarySelection(self, arbitrary, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a function to look for eigenvalues according to an arbitrary selection
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setArbitrarySelection", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_ctx);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1205
 *     #
 * 
 *     def setEigenvalueComparison(self, comparison, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the eigenvalue comparison function when
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_113setEigenvalueComparison(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_112setEigenvalueComparison[] = "EPS.setEigenvalueComparison(self, comparison, args=None, kargs=None)\n\n        Specifies the eigenvalue comparison function when\n        `setWhichEigenpairs()` is set to `EPS.Which.USER`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_113setEigenvalueComparison(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comparison = 0;
  PyObject *__pyx_v_args = 0;
  PyObject *__pyx_v_kargs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setEigenvalueComparison (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comparison,&__pyx_n_s_args,&__pyx_n_s_kargs,0};
    PyObject* values[3] = {0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comparison)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kargs);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setEigenvalueComparison") < 0)) __PYX_ERR(17, 1205, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_comparison = values[0];
    __pyx_v_args = values[1];
    __pyx_v_kargs = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setEigenvalueComparison", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1205, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setEigenvalueComparison", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_112setEigenvalueComparison(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_comparison, __pyx_v_args, __pyx_v_kargs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_112setEigenvalueComparison(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_comparison, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs) {
  PyObject *__pyx_v_ctx = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setEigenvalueComparison", 0);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);

  /* "SLEPc/EPS.pyx":1210
 *         `setWhichEigenpairs()` is set to `EPS.Which.USER`.
 *         """
 *         if comparison is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
  __pyx_t_1 = (__pyx_v_comparison != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "SLEPc/EPS.pyx":1211
 *         """
 *         if comparison is not None:
 *             if args is None: args = ()             # <<<<<<<<<<<<<<
 *             if kargs is None: kargs = {}
 *             self.set_attr('__comparison__', (comparison, args, kargs))
 */
    __pyx_t_2 = (__pyx_v_args == Py_None);
    __pyx_t_1 = (__pyx_t_2 != 0);
    if (__pyx_t_1) {
      __Pyx_INCREF(__pyx_empty_tuple);
      __Pyx_DECREF_SET(__pyx_v_args, __pyx_empty_tuple);
    }

    /* "SLEPc/EPS.pyx":1212
 *         if comparison is not None:
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}             # <<<<<<<<<<<<<<
 *             self.set_attr('__comparison__', (comparison, args, kargs))
 *             ctx = self.get_attr('__comparison__')
 */
    __pyx_t_1 = (__pyx_v_kargs == Py_None);
    __pyx_t_2 = (__pyx_t_1 != 0);
    if (__pyx_t_2) {
      __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1212, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF_SET(__pyx_v_kargs, __pyx_t_3);
      __pyx_t_3 = 0;
    }

    /* "SLEPc/EPS.pyx":1213
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 *             self.set_attr('__comparison__', (comparison, args, kargs))             # <<<<<<<<<<<<<<
 *             ctx = self.get_attr('__comparison__')
 *             CHKERR( EPSSetEigenvalueComparison(self.eps, EPS_Comparison, <void*>ctx) )
 */
    __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1213, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_comparison);
    __Pyx_GIVEREF(__pyx_v_comparison);
    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_comparison);
    __Pyx_INCREF(__pyx_v_args);
    __Pyx_GIVEREF(__pyx_v_args);
    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_args);
    __Pyx_INCREF(__pyx_v_kargs);
    __Pyx_GIVEREF(__pyx_v_kargs);
    PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_kargs);
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__comparison__"), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 1213, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "SLEPc/EPS.pyx":1214
 *             if kargs is None: kargs = {}
 *             self.set_attr('__comparison__', (comparison, args, kargs))
 *             ctx = self.get_attr('__comparison__')             # <<<<<<<<<<<<<<
 *             CHKERR( EPSSetEigenvalueComparison(self.eps, EPS_Comparison, <void*>ctx) )
 *         else:
 */
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__comparison__")); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 1214, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_v_ctx = __pyx_t_4;
    __pyx_t_4 = 0;

    /* "SLEPc/EPS.pyx":1215
 *             self.set_attr('__comparison__', (comparison, args, kargs))
 *             ctx = self.get_attr('__comparison__')
 *             CHKERR( EPSSetEigenvalueComparison(self.eps, EPS_Comparison, <void*>ctx) )             # <<<<<<<<<<<<<<
 *         else:
 *             self.set_attr('__comparison__', None)
 */
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetEigenvalueComparison(__pyx_v_self->eps, __pyx_f_8slepc4py_5SLEPc_EPS_Comparison, ((void *)__pyx_v_ctx))); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(17, 1215, __pyx_L1_error)

    /* "SLEPc/EPS.pyx":1210
 *         `setWhichEigenpairs()` is set to `EPS.Which.USER`.
 *         """
 *         if comparison is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
    goto __pyx_L3;
  }

  /* "SLEPc/EPS.pyx":1217
 *             CHKERR( EPSSetEigenvalueComparison(self.eps, EPS_Comparison, <void*>ctx) )
 *         else:
 *             self.set_attr('__comparison__', None)             # <<<<<<<<<<<<<<
 *             CHKERR( EPSSetEigenvalueComparison(self.eps, NULL, NULL) )
 * 
 */
  /*else*/ {
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__comparison__"), Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 1217, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "SLEPc/EPS.pyx":1218
 *         else:
 *             self.set_attr('__comparison__', None)
 *             CHKERR( EPSSetEigenvalueComparison(self.eps, NULL, NULL) )             # <<<<<<<<<<<<<<
 * 
 *     def setMonitor(self, monitor, args=None, kargs=None):
 */
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetEigenvalueComparison(__pyx_v_self->eps, NULL, NULL)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(17, 1218, __pyx_L1_error)
  }
  __pyx_L3:;

  /* "SLEPc/EPS.pyx":1205
 *     #
 * 
 *     def setEigenvalueComparison(self, comparison, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the eigenvalue comparison function when
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setEigenvalueComparison", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_ctx);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1220
 *             CHKERR( EPSSetEigenvalueComparison(self.eps, NULL, NULL) )
 * 
 *     def setMonitor(self, monitor, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Appends a monitor function to the list of monitors.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_115setMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_114setMonitor[] = "EPS.setMonitor(self, monitor, args=None, kargs=None)\n\n        Appends a monitor function to the list of monitors.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_115setMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_monitor = 0;
  PyObject *__pyx_v_args = 0;
  PyObject *__pyx_v_kargs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setMonitor (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_monitor,&__pyx_n_s_args,&__pyx_n_s_kargs,0};
    PyObject* values[3] = {0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_monitor)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kargs);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setMonitor") < 0)) __PYX_ERR(17, 1220, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_monitor = values[0];
    __pyx_v_args = values[1];
    __pyx_v_kargs = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setMonitor", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1220, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_114setMonitor(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_monitor, __pyx_v_args, __pyx_v_kargs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_114setMonitor(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_monitor, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs) {
  PyObject *__pyx_v_monitorlist = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setMonitor", 0);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);

  /* "SLEPc/EPS.pyx":1224
 *         Appends a monitor function to the list of monitors.
 *         """
 *         if monitor is None: return             # <<<<<<<<<<<<<<
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:
 */
  __pyx_t_1 = (__pyx_v_monitor == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;
  }

  /* "SLEPc/EPS.pyx":1225
 *         """
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 *         if monitorlist is None:
 *             monitorlist = []
 */
  __pyx_t_3 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__")); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_monitorlist = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/EPS.pyx":1226
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:             # <<<<<<<<<<<<<<
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 */
  __pyx_t_2 = (__pyx_v_monitorlist == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {

    /* "SLEPc/EPS.pyx":1227
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:
 *             monitorlist = []             # <<<<<<<<<<<<<<
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( EPSMonitorSet(self.eps, EPS_Monitor, NULL, NULL) )
 */
    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1227, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_monitorlist, __pyx_t_3);
    __pyx_t_3 = 0;

    /* "SLEPc/EPS.pyx":1228
 *         if monitorlist is None:
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)             # <<<<<<<<<<<<<<
 *             CHKERR( EPSMonitorSet(self.eps, EPS_Monitor, NULL, NULL) )
 *         if args is None: args = ()
 */
    __pyx_t_3 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__"), __pyx_v_monitorlist); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1228, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

    /* "SLEPc/EPS.pyx":1229
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( EPSMonitorSet(self.eps, EPS_Monitor, NULL, NULL) )             # <<<<<<<<<<<<<<
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSMonitorSet(__pyx_v_self->eps, __pyx_f_8slepc4py_5SLEPc_EPS_Monitor, NULL, NULL)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(17, 1229, __pyx_L1_error)

    /* "SLEPc/EPS.pyx":1226
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:             # <<<<<<<<<<<<<<
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 */
  }

  /* "SLEPc/EPS.pyx":1230
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( EPSMonitorSet(self.eps, EPS_Monitor, NULL, NULL) )
 *         if args is None: args = ()             # <<<<<<<<<<<<<<
 *         if kargs is None: kargs = {}
 *         monitorlist.append((monitor, args, kargs))
 */
  __pyx_t_1 = (__pyx_v_args == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __Pyx_INCREF(__pyx_empty_tuple);
    __Pyx_DECREF_SET(__pyx_v_args, __pyx_empty_tuple);
  }

  /* "SLEPc/EPS.pyx":1231
 *             CHKERR( EPSMonitorSet(self.eps, EPS_Monitor, NULL, NULL) )
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}             # <<<<<<<<<<<<<<
 *         monitorlist.append((monitor, args, kargs))
 * 
 */
  __pyx_t_2 = (__pyx_v_kargs == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1231, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_kargs, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/EPS.pyx":1232
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}
 *         monitorlist.append((monitor, args, kargs))             # <<<<<<<<<<<<<<
 * 
 *     def getMonitor(self):
 */
  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1232, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_monitor);
  __Pyx_GIVEREF(__pyx_v_monitor);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_monitor);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_GIVEREF(__pyx_v_args);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);
  __Pyx_GIVEREF(__pyx_v_kargs);
  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_kargs);
  __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_monitorlist, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(17, 1232, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/EPS.pyx":1220
 *             CHKERR( EPSSetEigenvalueComparison(self.eps, NULL, NULL) )
 * 
 *     def setMonitor(self, monitor, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Appends a monitor function to the list of monitors.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_monitorlist);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1234
 *         monitorlist.append((monitor, args, kargs))
 * 
 *     def getMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the list of monitor functions.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_117getMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_116getMonitor[] = "EPS.getMonitor(self)\n\n        Gets the list of monitor functions.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_117getMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getMonitor (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getMonitor", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getMonitor", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_116getMonitor(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_116getMonitor(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getMonitor", 0);

  /* "SLEPc/EPS.pyx":1238
 *         Gets the list of monitor functions.
 *         """
 *         return self.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 * 
 *     def cancelMonitor(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1238, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1234
 *         monitorlist.append((monitor, args, kargs))
 * 
 *     def getMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the list of monitor functions.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1240
 *         return self.get_attr('__monitor__')
 * 
 *     def cancelMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Clears all monitors for an `EPS` object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_119cancelMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_118cancelMonitor[] = "EPS.cancelMonitor(self)\n\n        Clears all monitors for an `EPS` object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_119cancelMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("cancelMonitor (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("cancelMonitor", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "cancelMonitor", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_118cancelMonitor(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_118cancelMonitor(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("cancelMonitor", 0);

  /* "SLEPc/EPS.pyx":1244
 *         Clears all monitors for an `EPS` object.
 *         """
 *         CHKERR( EPSMonitorCancel(self.eps) )             # <<<<<<<<<<<<<<
 *         self.set_attr('__monitor__', None)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSMonitorCancel(__pyx_v_self->eps)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1244, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1245
 *         """
 *         CHKERR( EPSMonitorCancel(self.eps) )
 *         self.set_attr('__monitor__', None)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_2 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__"), Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 1245, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/EPS.pyx":1240
 *         return self.get_attr('__monitor__')
 * 
 *     def cancelMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Clears all monitors for an `EPS` object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.cancelMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1249
 *     #
 * 
 *     def setUp(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets up all the internal data structures necessary for the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_121setUp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_120setUp[] = "EPS.setUp(self)\n\n        Sets up all the internal data structures necessary for the\n        execution of the eigensolver.\n\n        Notes\n        -----\n        This function need not be called explicitly in most cases,\n        since `solve()` calls it. It can be useful when one wants to\n        measure the set-up time separately from the solve time.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_121setUp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setUp (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setUp", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setUp", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_120setUp(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_120setUp(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setUp", 0);

  /* "SLEPc/EPS.pyx":1260
 *         measure the set-up time separately from the solve time.
 *         """
 *         CHKERR( EPSSetUp(self.eps) )             # <<<<<<<<<<<<<<
 * 
 *     def solve(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSetUp(__pyx_v_self->eps)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1260, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1249
 *     #
 * 
 *     def setUp(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets up all the internal data structures necessary for the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setUp", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1262
 *         CHKERR( EPSSetUp(self.eps) )
 * 
 *     def solve(self):             # <<<<<<<<<<<<<<
 *         """
 *         Solves the eigensystem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_123solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_122solve[] = "EPS.solve(self)\n\n        Solves the eigensystem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_123solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("solve (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("solve", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "solve", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_122solve(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_122solve(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("solve", 0);

  /* "SLEPc/EPS.pyx":1266
 *         Solves the eigensystem.
 *         """
 *         CHKERR( EPSSolve(self.eps) )             # <<<<<<<<<<<<<<
 * 
 *     def getIterationNumber(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSSolve(__pyx_v_self->eps)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1266, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1262
 *         CHKERR( EPSSetUp(self.eps) )
 * 
 *     def solve(self):             # <<<<<<<<<<<<<<
 *         """
 *         Solves the eigensystem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.solve", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1268
 *         CHKERR( EPSSolve(self.eps) )
 * 
 *     def getIterationNumber(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the current iteration number. If the call to `solve()` is
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_125getIterationNumber(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_124getIterationNumber[] = "EPS.getIterationNumber(self)\n\n        Gets the current iteration number. If the call to `solve()` is\n        complete, then it returns the number of iterations carried out\n        by the solution method.\n\n        Returns\n        -------\n        its: int\n             Iteration number.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_125getIterationNumber(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getIterationNumber (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getIterationNumber", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getIterationNumber", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_124getIterationNumber(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_124getIterationNumber(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getIterationNumber", 0);

  /* "SLEPc/EPS.pyx":1279
 *              Iteration number.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetIterationNumber(self.eps, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/EPS.pyx":1280
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( EPSGetIterationNumber(self.eps, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetIterationNumber(__pyx_v_self->eps, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1280, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1281
 *         cdef PetscInt ival = 0
 *         CHKERR( EPSGetIterationNumber(self.eps, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def getConvergedReason(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 1281, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1268
 *         CHKERR( EPSSolve(self.eps) )
 * 
 *     def getIterationNumber(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the current iteration number. If the call to `solve()` is
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getIterationNumber", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1283
 *         return toInt(ival)
 * 
 *     def getConvergedReason(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the reason why the `solve()` iteration was stopped.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_127getConvergedReason(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_126getConvergedReason[] = "EPS.getConvergedReason(self)\n\n        Gets the reason why the `solve()` iteration was stopped.\n\n        Returns\n        -------\n        reason: `EPS.ConvergedReason` enumerate\n                Negative value indicates diverged, positive value\n                converged.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_127getConvergedReason(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getConvergedReason (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getConvergedReason", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConvergedReason", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_126getConvergedReason(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_126getConvergedReason(struct PySlepcEPSObject *__pyx_v_self) {
  EPSConvergedReason __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getConvergedReason", 0);

  /* "SLEPc/EPS.pyx":1293
 *                 converged.
 *         """
 *         cdef SlepcEPSConvergedReason val = EPS_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetConvergedReason(self.eps, &val) )
 *         return val
 */
  __pyx_v_val = EPS_CONVERGED_ITERATING;

  /* "SLEPc/EPS.pyx":1294
 *         """
 *         cdef SlepcEPSConvergedReason val = EPS_CONVERGED_ITERATING
 *         CHKERR( EPSGetConvergedReason(self.eps, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetConvergedReason(__pyx_v_self->eps, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1294, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1295
 *         cdef SlepcEPSConvergedReason val = EPS_CONVERGED_ITERATING
 *         CHKERR( EPSGetConvergedReason(self.eps, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def getConverged(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_EPSConvergedReason(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 1295, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1283
 *         return toInt(ival)
 * 
 *     def getConvergedReason(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the reason why the `solve()` iteration was stopped.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getConvergedReason", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1297
 *         return val
 * 
 *     def getConverged(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of converged eigenpairs.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_129getConverged(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_128getConverged[] = "EPS.getConverged(self)\n\n        Gets the number of converged eigenpairs.\n\n        Returns\n        -------\n        nconv: int\n               Number of converged eigenpairs.\n\n        Notes\n        -----\n        This function should be called after `solve()` has finished.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_129getConverged(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getConverged (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getConverged", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConverged", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_128getConverged(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_128getConverged(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getConverged", 0);

  /* "SLEPc/EPS.pyx":1310
 *         This function should be called after `solve()` has finished.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetConverged(self.eps, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/EPS.pyx":1311
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( EPSGetConverged(self.eps, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetConverged(__pyx_v_self->eps, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1311, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1312
 *         cdef PetscInt ival = 0
 *         CHKERR( EPSGetConverged(self.eps, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def getEigenvalue(self, int i):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 1312, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1297
 *         return val
 * 
 *     def getConverged(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of converged eigenpairs.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getConverged", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1314
 *         return toInt(ival)
 * 
 *     def getEigenvalue(self, int i):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th eigenvalue as computed by `solve()`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_131getEigenvalue(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_130getEigenvalue[] = "EPS.getEigenvalue(self, int i)\n\n        Gets the i-th eigenvalue as computed by `solve()`.\n\n        Parameters\n        ----------\n        i: int\n           Index of the solution to be obtained.\n\n        Returns\n        -------\n        e: scalar (possibly complex)\n           The computed eigenvalue.\n\n        Notes\n        -----\n        The index ``i`` should be a value between ``0`` and\n        ``nconv-1`` (see `getConverged()`). Eigenpairs are indexed\n        according to the ordering criterion established with\n        `setWhichEigenpairs()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_131getEigenvalue(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getEigenvalue (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getEigenvalue") < 0)) __PYX_ERR(17, 1314, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(17, 1314, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getEigenvalue", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1314, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getEigenvalue", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_130getEigenvalue(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_i);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_130getEigenvalue(struct PySlepcEPSObject *__pyx_v_self, int __pyx_v_i) {
  PetscScalar __pyx_v_sval1;
  PetscScalar __pyx_v_sval2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getEigenvalue", 0);

  /* "SLEPc/EPS.pyx":1335
 *         `setWhichEigenpairs()`.
 *         """
 *         cdef PetscScalar sval1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar sval2 = 0
 *         CHKERR( EPSGetEigenvalue(self.eps, i, &sval1, &sval2) )
 */
  __pyx_v_sval1 = 0.0;

  /* "SLEPc/EPS.pyx":1336
 *         """
 *         cdef PetscScalar sval1 = 0
 *         cdef PetscScalar sval2 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetEigenvalue(self.eps, i, &sval1, &sval2) )
 *         return toComplex(sval1, sval2)
 */
  __pyx_v_sval2 = 0.0;

  /* "SLEPc/EPS.pyx":1337
 *         cdef PetscScalar sval1 = 0
 *         cdef PetscScalar sval2 = 0
 *         CHKERR( EPSGetEigenvalue(self.eps, i, &sval1, &sval2) )             # <<<<<<<<<<<<<<
 *         return toComplex(sval1, sval2)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetEigenvalue(__pyx_v_self->eps, __pyx_v_i, (&__pyx_v_sval1), (&__pyx_v_sval2))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1337, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1338
 *         cdef PetscScalar sval2 = 0
 *         CHKERR( EPSGetEigenvalue(self.eps, i, &sval1, &sval2) )
 *         return toComplex(sval1, sval2)             # <<<<<<<<<<<<<<
 * 
 *     def getEigenvector(self, int i, Vec Vr, Vec Vi=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toComplex(__pyx_v_sval1, __pyx_v_sval2); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 1338, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1314
 *         return toInt(ival)
 * 
 *     def getEigenvalue(self, int i):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th eigenvalue as computed by `solve()`.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getEigenvalue", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1340
 *         return toComplex(sval1, sval2)
 * 
 *     def getEigenvector(self, int i, Vec Vr, Vec Vi=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th eigenvector as computed by `solve()`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_133getEigenvector(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_132getEigenvector[] = "EPS.getEigenvector(self, int i, Vec Vr, Vec Vi=None)\n\n        Gets the i-th eigenvector as computed by `solve()`.\n\n        Parameters\n        ----------\n        i: int\n           Index of the solution to be obtained.\n        Vr: Vec\n            Placeholder for the returned eigenvector (real part).\n        Vi: Vec, optional\n            Placeholder for the returned eigenvector (imaginary part).\n\n        Notes\n        -----\n        The index ``i`` should be a value between ``0`` and\n        ``nconv-1`` (see `getConverged()`). Eigenpairs are indexed\n        according to the ordering criterion established with\n        `setWhichEigenpairs()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_133getEigenvector(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  struct PyPetscVecObject *__pyx_v_Vr = 0;
  struct PyPetscVecObject *__pyx_v_Vi = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getEigenvector (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,&__pyx_n_s_Vr,&__pyx_n_s_Vi,0};
    PyObject* values[3] = {0,0,0};
    values[2] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Vr)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("getEigenvector", 0, 2, 3, 1); __PYX_ERR(17, 1340, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Vi);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getEigenvector") < 0)) __PYX_ERR(17, 1340, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(17, 1340, __pyx_L3_error)
    __pyx_v_Vr = ((struct PyPetscVecObject *)values[1]);
    __pyx_v_Vi = ((struct PyPetscVecObject *)values[2]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getEigenvector", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1340, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getEigenvector", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Vr), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "Vr", 0))) __PYX_ERR(17, 1340, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Vi), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "Vi", 0))) __PYX_ERR(17, 1340, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_132getEigenvector(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_i, __pyx_v_Vr, __pyx_v_Vi);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_132getEigenvector(struct PySlepcEPSObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_Vr, struct PyPetscVecObject *__pyx_v_Vi) {
  Vec __pyx_v_vecr;
  Vec __pyx_v_veci;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Vec __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getEigenvector", 0);

  /* "SLEPc/EPS.pyx":1360
 *         `setWhichEigenpairs()`.
 *         """
 *         cdef PetscVec vecr = Vr.vec             # <<<<<<<<<<<<<<
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL
 *         CHKERR( EPSGetEigenvector(self.eps, i, vecr, veci) )
 */
  __pyx_t_1 = __pyx_v_Vr->vec;
  __pyx_v_vecr = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1361
 *         """
 *         cdef PetscVec vecr = Vr.vec
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetEigenvector(self.eps, i, vecr, veci) )
 * 
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_Vi) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_Vi->vec;
  } else {
    __pyx_t_1 = ((Vec)NULL);
  }
  __pyx_v_veci = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1362
 *         cdef PetscVec vecr = Vr.vec
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL
 *         CHKERR( EPSGetEigenvector(self.eps, i, vecr, veci) )             # <<<<<<<<<<<<<<
 * 
 *     def getLeftEigenvector(self, int i, Vec Wr, Vec Wi=None):
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetEigenvector(__pyx_v_self->eps, __pyx_v_i, __pyx_v_vecr, __pyx_v_veci)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(17, 1362, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1340
 *         return toComplex(sval1, sval2)
 * 
 *     def getEigenvector(self, int i, Vec Vr, Vec Vi=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th eigenvector as computed by `solve()`.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getEigenvector", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1364
 *         CHKERR( EPSGetEigenvector(self.eps, i, vecr, veci) )
 * 
 *     def getLeftEigenvector(self, int i, Vec Wr, Vec Wi=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th left eigenvector as computed by `solve()`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_135getLeftEigenvector(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_134getLeftEigenvector[] = "EPS.getLeftEigenvector(self, int i, Vec Wr, Vec Wi=None)\n\n        Gets the i-th left eigenvector as computed by `solve()`.\n\n        Parameters\n        ----------\n        i: int\n           Index of the solution to be obtained.\n        Wr: Vec\n            Placeholder for the returned eigenvector (real part).\n        Wi: Vec, optional\n            Placeholder for the returned eigenvector (imaginary part).\n\n        Notes\n        -----\n        The index ``i`` should be a value between ``0`` and\n        ``nconv-1`` (see `getConverged()`). Eigensolutions are indexed\n        according to the ordering criterion established with\n        `setWhichEigenpairs()`.\n\n        Left eigenvectors are available only if the twosided flag was set\n        with `setTwoSided()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_135getLeftEigenvector(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  struct PyPetscVecObject *__pyx_v_Wr = 0;
  struct PyPetscVecObject *__pyx_v_Wi = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getLeftEigenvector (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,&__pyx_n_s_Wr,&__pyx_n_s_Wi,0};
    PyObject* values[3] = {0,0,0};
    values[2] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Wr)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("getLeftEigenvector", 0, 2, 3, 1); __PYX_ERR(17, 1364, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Wi);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getLeftEigenvector") < 0)) __PYX_ERR(17, 1364, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(17, 1364, __pyx_L3_error)
    __pyx_v_Wr = ((struct PyPetscVecObject *)values[1]);
    __pyx_v_Wi = ((struct PyPetscVecObject *)values[2]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getLeftEigenvector", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1364, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getLeftEigenvector", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Wr), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "Wr", 0))) __PYX_ERR(17, 1364, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Wi), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "Wi", 0))) __PYX_ERR(17, 1364, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_134getLeftEigenvector(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_i, __pyx_v_Wr, __pyx_v_Wi);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_134getLeftEigenvector(struct PySlepcEPSObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_Wr, struct PyPetscVecObject *__pyx_v_Wi) {
  Vec __pyx_v_vecr;
  Vec __pyx_v_veci;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Vec __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getLeftEigenvector", 0);

  /* "SLEPc/EPS.pyx":1387
 *         with `setTwoSided()`.
 *         """
 *         cdef PetscVec vecr = Wr.vec             # <<<<<<<<<<<<<<
 *         cdef PetscVec veci = Wi.vec if Wi is not None else <PetscVec>NULL
 *         CHKERR( EPSGetLeftEigenvector(self.eps, i, vecr, veci) )
 */
  __pyx_t_1 = __pyx_v_Wr->vec;
  __pyx_v_vecr = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1388
 *         """
 *         cdef PetscVec vecr = Wr.vec
 *         cdef PetscVec veci = Wi.vec if Wi is not None else <PetscVec>NULL             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetLeftEigenvector(self.eps, i, vecr, veci) )
 * 
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_Wi) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_Wi->vec;
  } else {
    __pyx_t_1 = ((Vec)NULL);
  }
  __pyx_v_veci = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1389
 *         cdef PetscVec vecr = Wr.vec
 *         cdef PetscVec veci = Wi.vec if Wi is not None else <PetscVec>NULL
 *         CHKERR( EPSGetLeftEigenvector(self.eps, i, vecr, veci) )             # <<<<<<<<<<<<<<
 * 
 *     def getEigenpair(self, int i, Vec Vr=None, Vec Vi=None):
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetLeftEigenvector(__pyx_v_self->eps, __pyx_v_i, __pyx_v_vecr, __pyx_v_veci)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(17, 1389, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1364
 *         CHKERR( EPSGetEigenvector(self.eps, i, vecr, veci) )
 * 
 *     def getLeftEigenvector(self, int i, Vec Wr, Vec Wi=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th left eigenvector as computed by `solve()`.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getLeftEigenvector", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1391
 *         CHKERR( EPSGetLeftEigenvector(self.eps, i, vecr, veci) )
 * 
 *     def getEigenpair(self, int i, Vec Vr=None, Vec Vi=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th solution of the eigenproblem as computed by
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_137getEigenpair(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_136getEigenpair[] = "EPS.getEigenpair(self, int i, Vec Vr=None, Vec Vi=None)\n\n        Gets the i-th solution of the eigenproblem as computed by\n        `solve()`.  The solution consists of both the eigenvalue and\n        the eigenvector.\n\n        Parameters\n        ----------\n        i: int\n           Index of the solution to be obtained.\n        Vr: Vec\n            Placeholder for the returned eigenvector (real part).\n        Vi: Vec\n            Placeholder for the returned eigenvector (imaginary part).\n\n        Returns\n        -------\n        e: scalar (possibly complex)\n           The computed eigenvalue.\n\n        Notes\n        -----\n        The index ``i`` should be a value between ``0`` and\n        ``nconv-1`` (see `getConverged()`). Eigenpairs are indexed\n        according to the ordering criterion established with\n        `setWhichEigenpairs()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_137getEigenpair(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  struct PyPetscVecObject *__pyx_v_Vr = 0;
  struct PyPetscVecObject *__pyx_v_Vi = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getEigenpair (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,&__pyx_n_s_Vr,&__pyx_n_s_Vi,0};
    PyObject* values[3] = {0,0,0};
    values[1] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    values[2] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Vr);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Vi);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getEigenpair") < 0)) __PYX_ERR(17, 1391, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(17, 1391, __pyx_L3_error)
    __pyx_v_Vr = ((struct PyPetscVecObject *)values[1]);
    __pyx_v_Vi = ((struct PyPetscVecObject *)values[2]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getEigenpair", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1391, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getEigenpair", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Vr), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "Vr", 0))) __PYX_ERR(17, 1391, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Vi), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "Vi", 0))) __PYX_ERR(17, 1391, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_136getEigenpair(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_i, __pyx_v_Vr, __pyx_v_Vi);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_136getEigenpair(struct PySlepcEPSObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_Vr, struct PyPetscVecObject *__pyx_v_Vi) {
  PetscScalar __pyx_v_sval1;
  PetscScalar __pyx_v_sval2;
  Vec __pyx_v_vecr;
  Vec __pyx_v_veci;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Vec __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getEigenpair", 0);

  /* "SLEPc/EPS.pyx":1418
 *         `setWhichEigenpairs()`.
 *         """
 *         cdef PetscScalar sval1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar sval2 = 0
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL
 */
  __pyx_v_sval1 = 0.0;

  /* "SLEPc/EPS.pyx":1419
 *         """
 *         cdef PetscScalar sval1 = 0
 *         cdef PetscScalar sval2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL
 */
  __pyx_v_sval2 = 0.0;

  /* "SLEPc/EPS.pyx":1420
 *         cdef PetscScalar sval1 = 0
 *         cdef PetscScalar sval2 = 0
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL             # <<<<<<<<<<<<<<
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL
 *         CHKERR( EPSGetEigenpair(self.eps, i, &sval1, &sval2, vecr, veci) )
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_Vr) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_Vr->vec;
  } else {
    __pyx_t_1 = ((Vec)NULL);
  }
  __pyx_v_vecr = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1421
 *         cdef PetscScalar sval2 = 0
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetEigenpair(self.eps, i, &sval1, &sval2, vecr, veci) )
 *         return toComplex(sval1, sval2)
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_Vi) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_Vi->vec;
  } else {
    __pyx_t_1 = ((Vec)NULL);
  }
  __pyx_v_veci = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1422
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL
 *         CHKERR( EPSGetEigenpair(self.eps, i, &sval1, &sval2, vecr, veci) )             # <<<<<<<<<<<<<<
 *         return toComplex(sval1, sval2)
 * 
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetEigenpair(__pyx_v_self->eps, __pyx_v_i, (&__pyx_v_sval1), (&__pyx_v_sval2), __pyx_v_vecr, __pyx_v_veci)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(17, 1422, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1423
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL
 *         CHKERR( EPSGetEigenpair(self.eps, i, &sval1, &sval2, vecr, veci) )
 *         return toComplex(sval1, sval2)             # <<<<<<<<<<<<<<
 * 
 *     def getInvariantSubspace(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toComplex(__pyx_v_sval1, __pyx_v_sval2); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 1423, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1391
 *         CHKERR( EPSGetLeftEigenvector(self.eps, i, vecr, veci) )
 * 
 *     def getEigenpair(self, int i, Vec Vr=None, Vec Vi=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th solution of the eigenproblem as computed by
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getEigenpair", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1425
 *         return toComplex(sval1, sval2)
 * 
 *     def getInvariantSubspace(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets an orthonormal basis of the computed invariant subspace.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_139getInvariantSubspace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_138getInvariantSubspace[] = "EPS.getInvariantSubspace(self)\n\n        Gets an orthonormal basis of the computed invariant subspace.\n\n        Returns\n        -------\n        subspace: list of Vec\n           Basis of the invariant subspace.\n\n        Notes\n        -----\n        This function should be called after `solve()` has finished.\n\n        The returned vectors span an invariant subspace associated\n        with the computed eigenvalues. An invariant subspace ``X`` of\n        ``A` satisfies ``A x`` in ``X`` for all ``x`` in ``X`` (a\n        similar definition applies for generalized eigenproblems).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_139getInvariantSubspace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getInvariantSubspace (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getInvariantSubspace", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getInvariantSubspace", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_138getInvariantSubspace(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_138getInvariantSubspace(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_i;
  PetscInt __pyx_v_ncv;
  Vec __pyx_v_v;
  Vec *__pyx_v_isp;
  PyObject *__pyx_v_subspace = 0;
  Mat __pyx_v_A;
  struct PyPetscVecObject *__pyx_v_V = 0;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_t_3;
  PetscInt __pyx_t_4;
  PetscInt __pyx_t_5;
  PetscInt __pyx_t_6;
  int __pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getInvariantSubspace", 0);

  /* "SLEPc/EPS.pyx":1443
 *         similar definition applies for generalized eigenproblems).
 *         """
 *         cdef PetscInt i = 0, ncv = 0             # <<<<<<<<<<<<<<
 *         cdef PetscVec v = NULL, *isp = NULL
 *         cdef list subspace = []
 */
  __pyx_v_i = 0;
  __pyx_v_ncv = 0;

  /* "SLEPc/EPS.pyx":1444
 *         """
 *         cdef PetscInt i = 0, ncv = 0
 *         cdef PetscVec v = NULL, *isp = NULL             # <<<<<<<<<<<<<<
 *         cdef list subspace = []
 *         CHKERR( EPSGetConverged(self.eps, &ncv) )
 */
  __pyx_v_v = NULL;
  __pyx_v_isp = NULL;

  /* "SLEPc/EPS.pyx":1445
 *         cdef PetscInt i = 0, ncv = 0
 *         cdef PetscVec v = NULL, *isp = NULL
 *         cdef list subspace = []             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetConverged(self.eps, &ncv) )
 *         if ncv == 0: return subspace
 */
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1445, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_subspace = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":1446
 *         cdef PetscVec v = NULL, *isp = NULL
 *         cdef list subspace = []
 *         CHKERR( EPSGetConverged(self.eps, &ncv) )             # <<<<<<<<<<<<<<
 *         if ncv == 0: return subspace
 *         cdef PetscMat A = NULL
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetConverged(__pyx_v_self->eps, (&__pyx_v_ncv))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1446, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1447
 *         cdef list subspace = []
 *         CHKERR( EPSGetConverged(self.eps, &ncv) )
 *         if ncv == 0: return subspace             # <<<<<<<<<<<<<<
 *         cdef PetscMat A = NULL
 *         CHKERR( EPSGetOperators(self.eps, &A, NULL) )
 */
  __pyx_t_3 = ((__pyx_v_ncv == 0) != 0);
  if (__pyx_t_3) {
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_subspace);
    __pyx_r = __pyx_v_subspace;
    goto __pyx_L0;
  }

  /* "SLEPc/EPS.pyx":1448
 *         CHKERR( EPSGetConverged(self.eps, &ncv) )
 *         if ncv == 0: return subspace
 *         cdef PetscMat A = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetOperators(self.eps, &A, NULL) )
 *         CHKERR( MatCreateVecs(A, &v, NULL) )
 */
  __pyx_v_A = NULL;

  /* "SLEPc/EPS.pyx":1449
 *         if ncv == 0: return subspace
 *         cdef PetscMat A = NULL
 *         CHKERR( EPSGetOperators(self.eps, &A, NULL) )             # <<<<<<<<<<<<<<
 *         CHKERR( MatCreateVecs(A, &v, NULL) )
 *         cdef Vec V = None
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetOperators(__pyx_v_self->eps, (&__pyx_v_A), NULL)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1449, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1450
 *         cdef PetscMat A = NULL
 *         CHKERR( EPSGetOperators(self.eps, &A, NULL) )
 *         CHKERR( MatCreateVecs(A, &v, NULL) )             # <<<<<<<<<<<<<<
 *         cdef Vec V = None
 *         cdef object tmp = allocate(<size_t>ncv*sizeof(PetscVec),<void**>&isp)
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MatCreateVecs(__pyx_v_A, (&__pyx_v_v), NULL)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1450, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1451
 *         CHKERR( EPSGetOperators(self.eps, &A, NULL) )
 *         CHKERR( MatCreateVecs(A, &v, NULL) )
 *         cdef Vec V = None             # <<<<<<<<<<<<<<
 *         cdef object tmp = allocate(<size_t>ncv*sizeof(PetscVec),<void**>&isp)
 *         for i in range(ncv):
 */
  __Pyx_INCREF(Py_None);
  __pyx_v_V = ((struct PyPetscVecObject *)Py_None);

  /* "SLEPc/EPS.pyx":1452
 *         CHKERR( MatCreateVecs(A, &v, NULL) )
 *         cdef Vec V = None
 *         cdef object tmp = allocate(<size_t>ncv*sizeof(PetscVec),<void**>&isp)             # <<<<<<<<<<<<<<
 *         for i in range(ncv):
 *             if i == 0: isp[0] = v
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_ncv) * (sizeof(Vec))), ((void **)(&__pyx_v_isp))); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1452, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_tmp = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":1453
 *         cdef Vec V = None
 *         cdef object tmp = allocate(<size_t>ncv*sizeof(PetscVec),<void**>&isp)
 *         for i in range(ncv):             # <<<<<<<<<<<<<<
 *             if i == 0: isp[0] = v
 *             if i >= 1: CHKERR( VecDuplicate(v, &isp[i]) )
 */
  __pyx_t_4 = __pyx_v_ncv;
  __pyx_t_5 = __pyx_t_4;
  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
    __pyx_v_i = __pyx_t_6;

    /* "SLEPc/EPS.pyx":1454
 *         cdef object tmp = allocate(<size_t>ncv*sizeof(PetscVec),<void**>&isp)
 *         for i in range(ncv):
 *             if i == 0: isp[0] = v             # <<<<<<<<<<<<<<
 *             if i >= 1: CHKERR( VecDuplicate(v, &isp[i]) )
 *             V = Vec(); V.vec = isp[i]; subspace.append(V)
 */
    __pyx_t_3 = ((__pyx_v_i == 0) != 0);
    if (__pyx_t_3) {
      (__pyx_v_isp[0]) = __pyx_v_v;
    }

    /* "SLEPc/EPS.pyx":1455
 *         for i in range(ncv):
 *             if i == 0: isp[0] = v
 *             if i >= 1: CHKERR( VecDuplicate(v, &isp[i]) )             # <<<<<<<<<<<<<<
 *             V = Vec(); V.vec = isp[i]; subspace.append(V)
 *         CHKERR( EPSGetInvariantSubspace(self.eps, isp) )
 */
    __pyx_t_3 = ((__pyx_v_i >= 1) != 0);
    if (__pyx_t_3) {
      __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(VecDuplicate(__pyx_v_v, (&(__pyx_v_isp[__pyx_v_i])))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1455, __pyx_L1_error)
    }

    /* "SLEPc/EPS.pyx":1456
 *             if i == 0: isp[0] = v
 *             if i >= 1: CHKERR( VecDuplicate(v, &isp[i]) )
 *             V = Vec(); V.vec = isp[i]; subspace.append(V)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetInvariantSubspace(self.eps, isp) )
 *         return subspace
 */
    __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Vec)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1456, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF_SET(__pyx_v_V, ((struct PyPetscVecObject *)__pyx_t_1));
    __pyx_t_1 = 0;
    __pyx_v_V->vec = (__pyx_v_isp[__pyx_v_i]);
    __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_subspace, ((PyObject *)__pyx_v_V)); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(17, 1456, __pyx_L1_error)
  }

  /* "SLEPc/EPS.pyx":1457
 *             if i >= 1: CHKERR( VecDuplicate(v, &isp[i]) )
 *             V = Vec(); V.vec = isp[i]; subspace.append(V)
 *         CHKERR( EPSGetInvariantSubspace(self.eps, isp) )             # <<<<<<<<<<<<<<
 *         return subspace
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetInvariantSubspace(__pyx_v_self->eps, __pyx_v_isp)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1457, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1458
 *             V = Vec(); V.vec = isp[i]; subspace.append(V)
 *         CHKERR( EPSGetInvariantSubspace(self.eps, isp) )
 *         return subspace             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_subspace);
  __pyx_r = __pyx_v_subspace;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1425
 *         return toComplex(sval1, sval2)
 * 
 *     def getInvariantSubspace(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets an orthonormal basis of the computed invariant subspace.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getInvariantSubspace", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_subspace);
  __Pyx_XDECREF((PyObject *)__pyx_v_V);
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1462
 *     #
 * 
 *     def getErrorEstimate(self, int i):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the error estimate associated to the i-th computed
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_141getErrorEstimate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_140getErrorEstimate[] = "EPS.getErrorEstimate(self, int i)\n\n        Returns the error estimate associated to the i-th computed\n        eigenpair.\n\n        Parameters\n        ----------\n        i: int\n           Index of the solution to be considered.\n\n        Returns\n        -------\n        e: real\n           Error estimate.\n\n        Notes\n        -----\n        This is the error estimate used internally by the\n        eigensolver. The actual error bound can be computed with\n        `computeError()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_141getErrorEstimate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getErrorEstimate (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getErrorEstimate") < 0)) __PYX_ERR(17, 1462, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(17, 1462, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getErrorEstimate", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1462, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getErrorEstimate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_140getErrorEstimate(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_i);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_140getErrorEstimate(struct PySlepcEPSObject *__pyx_v_self, int __pyx_v_i) {
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getErrorEstimate", 0);

  /* "SLEPc/EPS.pyx":1483
 *         `computeError()`.
 *         """
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGetErrorEstimate(self.eps, i, &rval) )
 *         return toReal(rval)
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/EPS.pyx":1484
 *         """
 *         cdef PetscReal rval = 0
 *         CHKERR( EPSGetErrorEstimate(self.eps, i, &rval) )             # <<<<<<<<<<<<<<
 *         return toReal(rval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGetErrorEstimate(__pyx_v_self->eps, __pyx_v_i, (&__pyx_v_rval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1484, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1485
 *         cdef PetscReal rval = 0
 *         CHKERR( EPSGetErrorEstimate(self.eps, i, &rval) )
 *         return toReal(rval)             # <<<<<<<<<<<<<<
 * 
 *     def computeError(self, int i, etype=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 1485, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1462
 *     #
 * 
 *     def getErrorEstimate(self, int i):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the error estimate associated to the i-th computed
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getErrorEstimate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1487
 *         return toReal(rval)
 * 
 *     def computeError(self, int i, etype=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the error (based on the residual norm) associated with the i-th
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_143computeError(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_142computeError[] = "EPS.computeError(self, int i, etype=None)\n\n        Computes the error (based on the residual norm) associated with the i-th\n        computed eigenpair.\n\n        Parameters\n        ----------\n        i: int\n           Index of the solution to be considered.\n        etype: `EPS.ErrorType` enumerate\n           The error type to compute.\n\n        Returns\n        -------\n        e: real\n           The error bound, computed in various ways from the residual norm\n           ``||Ax-kBx||_2`` where ``k`` is the eigenvalue and\n           ``x`` is the eigenvector.\n\n        Notes\n        -----\n        The index ``i`` should be a value between ``0`` and\n        ``nconv-1`` (see `getConverged()`).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_143computeError(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  PyObject *__pyx_v_etype = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("computeError (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,&__pyx_n_s_etype,0};
    PyObject* values[2] = {0,0};
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_etype);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "computeError") < 0)) __PYX_ERR(17, 1487, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(17, 1487, __pyx_L3_error)
    __pyx_v_etype = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("computeError", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1487, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.computeError", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_142computeError(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_i, __pyx_v_etype);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_142computeError(struct PySlepcEPSObject *__pyx_v_self, int __pyx_v_i, PyObject *__pyx_v_etype) {
  EPSErrorType __pyx_v_et;
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  EPSErrorType __pyx_t_3;
  int __pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("computeError", 0);

  /* "SLEPc/EPS.pyx":1511
 *         ``nconv-1`` (see `getConverged()`).
 *         """
 *         cdef SlepcEPSErrorType et = EPS_ERROR_RELATIVE             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval = 0
 *         if etype is not None: et = etype
 */
  __pyx_v_et = EPS_ERROR_RELATIVE;

  /* "SLEPc/EPS.pyx":1512
 *         """
 *         cdef SlepcEPSErrorType et = EPS_ERROR_RELATIVE
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         if etype is not None: et = etype
 *         CHKERR( EPSComputeError(self.eps, i, et, &rval) )
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/EPS.pyx":1513
 *         cdef SlepcEPSErrorType et = EPS_ERROR_RELATIVE
 *         cdef PetscReal rval = 0
 *         if etype is not None: et = etype             # <<<<<<<<<<<<<<
 *         CHKERR( EPSComputeError(self.eps, i, et, &rval) )
 *         return toReal(rval)
 */
  __pyx_t_1 = (__pyx_v_etype != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = ((EPSErrorType)__Pyx_PyInt_As_EPSErrorType(__pyx_v_etype)); if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 1513, __pyx_L1_error)
    __pyx_v_et = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":1514
 *         cdef PetscReal rval = 0
 *         if etype is not None: et = etype
 *         CHKERR( EPSComputeError(self.eps, i, et, &rval) )             # <<<<<<<<<<<<<<
 *         return toReal(rval)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSComputeError(__pyx_v_self->eps, __pyx_v_i, __pyx_v_et, (&__pyx_v_rval))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(17, 1514, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1515
 *         if etype is not None: et = etype
 *         CHKERR( EPSComputeError(self.eps, i, et, &rval) )
 *         return toReal(rval)             # <<<<<<<<<<<<<<
 * 
 *     def errorView(self, etype=None, Viewer viewer=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_5)) __PYX_ERR(17, 1515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1487
 *         return toReal(rval)
 * 
 *     def computeError(self, int i, etype=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the error (based on the residual norm) associated with the i-th
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.computeError", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1517
 *         return toReal(rval)
 * 
 *     def errorView(self, etype=None, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the errors associated with the computed solution
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_145errorView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_144errorView[] = "EPS.errorView(self, etype=None, Viewer viewer=None)\n\n        Displays the errors associated with the computed solution\n        (as well as the eigenvalues).\n\n        Parameters\n        ----------\n        etype: `EPS.ErrorType` enumerate, optional\n           The error type to compute.\n        viewer: Viewer, optional.\n                Visualization context; if not provided, the standard\n                output is used.\n\n        Notes\n        -----\n        By default, this function checks the error of all eigenpairs and prints\n        the eigenvalues if all of them are below the requested tolerance.\n        If the viewer has format ``ASCII_INFO_DETAIL`` then a table with\n        eigenvalues and corresponding errors is printed.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_145errorView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_etype = 0;
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("errorView (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_etype,&__pyx_n_s_viewer,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_etype);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "errorView") < 0)) __PYX_ERR(17, 1517, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_etype = values[0];
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("errorView", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1517, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.errorView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(17, 1517, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_144errorView(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_etype, __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_144errorView(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_etype, struct PyPetscViewerObject *__pyx_v_viewer) {
  EPSErrorType __pyx_v_et;
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  EPSErrorType __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("errorView", 0);

  /* "SLEPc/EPS.pyx":1537
 *         eigenvalues and corresponding errors is printed.
 *         """
 *         cdef SlepcEPSErrorType et = EPS_ERROR_RELATIVE             # <<<<<<<<<<<<<<
 *         if etype is not None: et = etype
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 */
  __pyx_v_et = EPS_ERROR_RELATIVE;

  /* "SLEPc/EPS.pyx":1538
 *         """
 *         cdef SlepcEPSErrorType et = EPS_ERROR_RELATIVE
 *         if etype is not None: et = etype             # <<<<<<<<<<<<<<
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( EPSErrorView(self.eps, et, vwr) )
 */
  __pyx_t_1 = (__pyx_v_etype != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = ((EPSErrorType)__Pyx_PyInt_As_EPSErrorType(__pyx_v_etype)); if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 1538, __pyx_L1_error)
    __pyx_v_et = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":1539
 *         cdef SlepcEPSErrorType et = EPS_ERROR_RELATIVE
 *         if etype is not None: et = etype
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSErrorView(self.eps, et, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/EPS.pyx":1540
 *         if etype is not None: et = etype
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( EPSErrorView(self.eps, et, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def valuesView(self, Viewer viewer=None):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSErrorView(__pyx_v_self->eps, __pyx_v_et, __pyx_v_vwr)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(17, 1540, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1517
 *         return toReal(rval)
 * 
 *     def errorView(self, etype=None, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the errors associated with the computed solution
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.errorView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1542
 *         CHKERR( EPSErrorView(self.eps, et, vwr) )
 * 
 *     def valuesView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the computed eigenvalues in a viewer.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_147valuesView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_146valuesView[] = "EPS.valuesView(self, Viewer viewer=None)\n\n        Displays the computed eigenvalues in a viewer.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional.\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_147valuesView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("valuesView (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "valuesView") < 0)) __PYX_ERR(17, 1542, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("valuesView", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1542, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.valuesView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(17, 1542, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_146valuesView(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_146valuesView(struct PySlepcEPSObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("valuesView", 0);

  /* "SLEPc/EPS.pyx":1552
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSValuesView(self.eps, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/EPS.pyx":1553
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( EPSValuesView(self.eps, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def vectorsView(self, Viewer viewer=None):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSValuesView(__pyx_v_self->eps, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1553, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1542
 *         CHKERR( EPSErrorView(self.eps, et, vwr) )
 * 
 *     def valuesView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the computed eigenvalues in a viewer.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.valuesView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1555
 *         CHKERR( EPSValuesView(self.eps, vwr) )
 * 
 *     def vectorsView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Outputs computed eigenvectors to a viewer.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_149vectorsView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_148vectorsView[] = "EPS.vectorsView(self, Viewer viewer=None)\n\n        Outputs computed eigenvectors to a viewer.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional.\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_149vectorsView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("vectorsView (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "vectorsView") < 0)) __PYX_ERR(17, 1555, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("vectorsView", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1555, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.vectorsView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(17, 1555, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_148vectorsView(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_148vectorsView(struct PySlepcEPSObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("vectorsView", 0);

  /* "SLEPc/EPS.pyx":1565
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSVectorsView(self.eps, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/EPS.pyx":1566
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( EPSVectorsView(self.eps, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSVectorsView(__pyx_v_self->eps, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1566, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1555
 *         CHKERR( EPSValuesView(self.eps, vwr) )
 * 
 *     def vectorsView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Outputs computed eigenvectors to a viewer.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.vectorsView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1570
 *     #
 * 
 *     def setPowerShiftType(self, shift):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the type of shifts used during the power iteration. This
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_151setPowerShiftType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_150setPowerShiftType[] = "EPS.setPowerShiftType(self, shift)\n\n        Sets the type of shifts used during the power iteration. This\n        can be used to emulate the Rayleigh Quotient Iteration (RQI)\n        method.\n\n        Parameters\n        ----------\n        shift: `EPS.PowerShiftType` enumerate\n               The type of shift.\n\n        Notes\n        -----\n        This call is only relevant if the type was set to\n        `EPS.Type.POWER` with `setType()`.\n\n        By default, shifts are constant\n        (`EPS.PowerShiftType.CONSTANT`) and the iteration is the\n        simple power method (or inverse iteration if a\n        shift-and-invert transformation is being used).\n\n        A variable shift can be specified\n        (`EPS.PowerShiftType.RAYLEIGH` or\n        `EPS.PowerShiftType.WILKINSON`). In this case, the iteration\n        behaves rather like a cubic converging method as RQI.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_151setPowerShiftType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_shift = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setPowerShiftType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shift,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shift)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setPowerShiftType") < 0)) __PYX_ERR(17, 1570, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_shift = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setPowerShiftType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1570, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setPowerShiftType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_150setPowerShiftType(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_shift);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_150setPowerShiftType(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_shift) {
  EPSPowerShiftType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  EPSPowerShiftType __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setPowerShiftType", 0);

  /* "SLEPc/EPS.pyx":1596
 *         behaves rather like a cubic converging method as RQI.
 *         """
 *         cdef SlepcEPSPowerShiftType val = shift             # <<<<<<<<<<<<<<
 *         CHKERR( EPSPowerSetShiftType(self.eps, val) )
 * 
 */
  __pyx_t_1 = ((EPSPowerShiftType)__Pyx_PyInt_As_EPSPowerShiftType(__pyx_v_shift)); if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 1596, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1597
 *         """
 *         cdef SlepcEPSPowerShiftType val = shift
 *         CHKERR( EPSPowerSetShiftType(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getPowerShiftType(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSPowerSetShiftType(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1597, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1570
 *     #
 * 
 *     def setPowerShiftType(self, shift):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the type of shifts used during the power iteration. This
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setPowerShiftType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1599
 *         CHKERR( EPSPowerSetShiftType(self.eps, val) )
 * 
 *     def getPowerShiftType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the type of shifts used during the power iteration.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_153getPowerShiftType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_152getPowerShiftType[] = "EPS.getPowerShiftType(self)\n\n        Gets the type of shifts used during the power iteration.\n\n        Returns\n        -------\n        shift: `EPS.PowerShiftType` enumerate\n               The type of shift.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_153getPowerShiftType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getPowerShiftType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getPowerShiftType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getPowerShiftType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_152getPowerShiftType(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_152getPowerShiftType(struct PySlepcEPSObject *__pyx_v_self) {
  EPSPowerShiftType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getPowerShiftType", 0);

  /* "SLEPc/EPS.pyx":1608
 *                The type of shift.
 *         """
 *         cdef SlepcEPSPowerShiftType val = EPS_POWER_SHIFT_CONSTANT             # <<<<<<<<<<<<<<
 *         CHKERR( EPSPowerGetShiftType(self.eps, &val) )
 *         return val
 */
  __pyx_v_val = EPS_POWER_SHIFT_CONSTANT;

  /* "SLEPc/EPS.pyx":1609
 *         """
 *         cdef SlepcEPSPowerShiftType val = EPS_POWER_SHIFT_CONSTANT
 *         CHKERR( EPSPowerGetShiftType(self.eps, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSPowerGetShiftType(__pyx_v_self->eps, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1609, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1610
 *         cdef SlepcEPSPowerShiftType val = EPS_POWER_SHIFT_CONSTANT
 *         CHKERR( EPSPowerGetShiftType(self.eps, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setArnoldiDelayed(self, delayed):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_EPSPowerShiftType(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 1610, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1599
 *         CHKERR( EPSPowerSetShiftType(self.eps, val) )
 * 
 *     def getPowerShiftType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the type of shifts used during the power iteration.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getPowerShiftType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1612
 *         return val
 * 
 *     def setArnoldiDelayed(self, delayed):             # <<<<<<<<<<<<<<
 *         """
 *         Activates or deactivates delayed reorthogonalization in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_155setArnoldiDelayed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_154setArnoldiDelayed[] = "EPS.setArnoldiDelayed(self, delayed)\n\n        Activates or deactivates delayed reorthogonalization in the\n        Arnoldi iteration.\n\n        Parameters\n        ----------\n        delayed: bool\n                 True if delayed reorthogonalization is to be used.\n\n        Notes\n        -----\n        This call is only relevant if the type was set to\n        `EPS.Type.ARNOLDI` with `setType()`.\n\n        Delayed reorthogonalization is an aggressive optimization for\n        the Arnoldi eigensolver than may provide better scalability,\n        but sometimes makes the solver converge less than the default\n        algorithm.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_155setArnoldiDelayed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_delayed = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setArnoldiDelayed (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_delayed,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delayed)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setArnoldiDelayed") < 0)) __PYX_ERR(17, 1612, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_delayed = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setArnoldiDelayed", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1612, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setArnoldiDelayed", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_154setArnoldiDelayed(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_delayed);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_154setArnoldiDelayed(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_delayed) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setArnoldiDelayed", 0);

  /* "SLEPc/EPS.pyx":1632
 *         algorithm.
 *         """
 *         cdef PetscBool val = asBool(delayed)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSArnoldiSetDelayed(self.eps, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_delayed); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 1632, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1633
 *         """
 *         cdef PetscBool val = asBool(delayed)
 *         CHKERR( EPSArnoldiSetDelayed(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getArnoldiDelayed(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSArnoldiSetDelayed(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1633, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1612
 *         return val
 * 
 *     def setArnoldiDelayed(self, delayed):             # <<<<<<<<<<<<<<
 *         """
 *         Activates or deactivates delayed reorthogonalization in the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setArnoldiDelayed", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1635
 *         CHKERR( EPSArnoldiSetDelayed(self.eps, val) )
 * 
 *     def getArnoldiDelayed(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the type of reorthogonalization used during the Arnoldi
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_157getArnoldiDelayed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_156getArnoldiDelayed[] = "EPS.getArnoldiDelayed(self)\n\n        Gets the type of reorthogonalization used during the Arnoldi\n        iteration.\n\n        Returns\n        -------\n        delayed: bool\n                 True if delayed reorthogonalization is to be used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_157getArnoldiDelayed(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getArnoldiDelayed (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getArnoldiDelayed", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getArnoldiDelayed", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_156getArnoldiDelayed(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_156getArnoldiDelayed(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getArnoldiDelayed", 0);

  /* "SLEPc/EPS.pyx":1645
 *                  True if delayed reorthogonalization is to be used.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSArnoldiGetDelayed(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":1646
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSArnoldiGetDelayed(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSArnoldiGetDelayed(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1646, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1647
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSArnoldiGetDelayed(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setLanczosReorthogType(self, reorthog):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 1647, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1635
 *         CHKERR( EPSArnoldiSetDelayed(self.eps, val) )
 * 
 *     def getArnoldiDelayed(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the type of reorthogonalization used during the Arnoldi
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getArnoldiDelayed", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1649
 *         return toBool(tval)
 * 
 *     def setLanczosReorthogType(self, reorthog):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the type of reorthogonalization used during the Lanczos
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_159setLanczosReorthogType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_158setLanczosReorthogType[] = "EPS.setLanczosReorthogType(self, reorthog)\n\n        Sets the type of reorthogonalization used during the Lanczos\n        iteration.\n\n        Parameters\n        ----------\n        reorthog: `EPS.LanczosReorthogType` enumerate\n                  The type of reorthogonalization.\n\n        Notes\n        -----\n        This call is only relevant if the type was set to\n        `EPS.Type.LANCZOS` with `setType()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_159setLanczosReorthogType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_reorthog = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setLanczosReorthogType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_reorthog,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_reorthog)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setLanczosReorthogType") < 0)) __PYX_ERR(17, 1649, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_reorthog = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setLanczosReorthogType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1649, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setLanczosReorthogType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_158setLanczosReorthogType(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_reorthog);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_158setLanczosReorthogType(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_reorthog) {
  EPSLanczosReorthogType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  EPSLanczosReorthogType __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setLanczosReorthogType", 0);

  /* "SLEPc/EPS.pyx":1664
 *         `EPS.Type.LANCZOS` with `setType()`.
 *         """
 *         cdef SlepcEPSLanczosReorthogType val = reorthog             # <<<<<<<<<<<<<<
 *         CHKERR( EPSLanczosSetReorthog(self.eps, val) )
 * 
 */
  __pyx_t_1 = ((EPSLanczosReorthogType)__Pyx_PyInt_As_EPSLanczosReorthogType(__pyx_v_reorthog)); if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 1664, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1665
 *         """
 *         cdef SlepcEPSLanczosReorthogType val = reorthog
 *         CHKERR( EPSLanczosSetReorthog(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getLanczosReorthogType(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSLanczosSetReorthog(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1665, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1649
 *         return toBool(tval)
 * 
 *     def setLanczosReorthogType(self, reorthog):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the type of reorthogonalization used during the Lanczos
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setLanczosReorthogType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1667
 *         CHKERR( EPSLanczosSetReorthog(self.eps, val) )
 * 
 *     def getLanczosReorthogType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the type of reorthogonalization used during the Lanczos
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_161getLanczosReorthogType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_160getLanczosReorthogType[] = "EPS.getLanczosReorthogType(self)\n\n        Gets the type of reorthogonalization used during the Lanczos\n        iteration.\n\n        Returns\n        -------\n        reorthog: `EPS.LanczosReorthogType` enumerate\n                  The type of reorthogonalization.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_161getLanczosReorthogType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getLanczosReorthogType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getLanczosReorthogType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLanczosReorthogType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_160getLanczosReorthogType(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_160getLanczosReorthogType(struct PySlepcEPSObject *__pyx_v_self) {
  EPSLanczosReorthogType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getLanczosReorthogType", 0);

  /* "SLEPc/EPS.pyx":1678
 *         """
 *         cdef SlepcEPSLanczosReorthogType val = \
 *             EPS_LANCZOS_REORTHOG_LOCAL             # <<<<<<<<<<<<<<
 *         CHKERR( EPSLanczosGetReorthog(self.eps, &val) )
 *         return val
 */
  __pyx_v_val = EPS_LANCZOS_REORTHOG_LOCAL;

  /* "SLEPc/EPS.pyx":1679
 *         cdef SlepcEPSLanczosReorthogType val = \
 *             EPS_LANCZOS_REORTHOG_LOCAL
 *         CHKERR( EPSLanczosGetReorthog(self.eps, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSLanczosGetReorthog(__pyx_v_self->eps, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1679, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1680
 *             EPS_LANCZOS_REORTHOG_LOCAL
 *         CHKERR( EPSLanczosGetReorthog(self.eps, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_EPSLanczosReorthogType(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 1680, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1667
 *         CHKERR( EPSLanczosSetReorthog(self.eps, val) )
 * 
 *     def getLanczosReorthogType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the type of reorthogonalization used during the Lanczos
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getLanczosReorthogType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1684
 *     #
 * 
 *     def setKrylovSchurRestart(self, keep):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the restart parameter for the Krylov-Schur method, in
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_163setKrylovSchurRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_162setKrylovSchurRestart[] = "EPS.setKrylovSchurRestart(self, keep)\n\n        Sets the restart parameter for the Krylov-Schur method, in\n        particular the proportion of basis vectors that must be kept\n        after restart.\n\n        Parameters\n        ----------\n        keep: float\n              The number of vectors to be kept at restart.\n\n        Notes\n        -----\n        Allowed values are in the range [0.1,0.9]. The default is 0.5.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_163setKrylovSchurRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_keep = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setKrylovSchurRestart (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_keep,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_keep)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setKrylovSchurRestart") < 0)) __PYX_ERR(17, 1684, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_keep = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setKrylovSchurRestart", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1684, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setKrylovSchurRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_162setKrylovSchurRestart(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_keep);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_162setKrylovSchurRestart(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_keep) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setKrylovSchurRestart", 0);

  /* "SLEPc/EPS.pyx":1699
 *         Allowed values are in the range [0.1,0.9]. The default is 0.5.
 *         """
 *         cdef PetscReal val = asReal(keep)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurSetRestart(self.eps, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_keep); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(17, 1699, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1700
 *         """
 *         cdef PetscReal val = asReal(keep)
 *         CHKERR( EPSKrylovSchurSetRestart(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getKrylovSchurRestart(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurSetRestart(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1700, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1684
 *     #
 * 
 *     def setKrylovSchurRestart(self, keep):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the restart parameter for the Krylov-Schur method, in
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setKrylovSchurRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1702
 *         CHKERR( EPSKrylovSchurSetRestart(self.eps, val) )
 * 
 *     def getKrylovSchurRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the restart parameter used in the Krylov-Schur method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_165getKrylovSchurRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_164getKrylovSchurRestart[] = "EPS.getKrylovSchurRestart(self)\n\n        Gets the restart parameter used in the Krylov-Schur method.\n\n        Returns\n        -------\n        keep: float\n              The number of vectors to be kept at restart.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_165getKrylovSchurRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getKrylovSchurRestart (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getKrylovSchurRestart", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getKrylovSchurRestart", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_164getKrylovSchurRestart(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_164getKrylovSchurRestart(struct PySlepcEPSObject *__pyx_v_self) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getKrylovSchurRestart", 0);

  /* "SLEPc/EPS.pyx":1711
 *               The number of vectors to be kept at restart.
 *         """
 *         cdef PetscReal val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurGetRestart(self.eps, &val) )
 *         return toReal(val)
 */
  __pyx_v_val = 0.0;

  /* "SLEPc/EPS.pyx":1712
 *         """
 *         cdef PetscReal val = 0
 *         CHKERR( EPSKrylovSchurGetRestart(self.eps, &val) )             # <<<<<<<<<<<<<<
 *         return toReal(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurGetRestart(__pyx_v_self->eps, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1712, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1713
 *         cdef PetscReal val = 0
 *         CHKERR( EPSKrylovSchurGetRestart(self.eps, &val) )
 *         return toReal(val)             # <<<<<<<<<<<<<<
 * 
 *     def setKrylovSchurLocking(self, lock):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 1713, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1702
 *         CHKERR( EPSKrylovSchurSetRestart(self.eps, val) )
 * 
 *     def getKrylovSchurRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the restart parameter used in the Krylov-Schur method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getKrylovSchurRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1715
 *         return toReal(val)
 * 
 *     def setKrylovSchurLocking(self, lock):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between locking and non-locking variants of the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_167setKrylovSchurLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_166setKrylovSchurLocking[] = "EPS.setKrylovSchurLocking(self, lock)\n\n        Choose between locking and non-locking variants of the\n        Krylov-Schur method.\n\n        Parameters\n        ----------\n        lock: bool\n              True if the locking variant must be selected.\n\n        Notes\n        -----\n        The default is to lock converged eigenpairs when the method restarts.\n        This behaviour can be changed so that all directions are kept in the\n        working subspace even if already converged to working accuracy (the\n        non-locking variant).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_167setKrylovSchurLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_lock = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setKrylovSchurLocking (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lock,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lock)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setKrylovSchurLocking") < 0)) __PYX_ERR(17, 1715, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_lock = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setKrylovSchurLocking", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1715, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setKrylovSchurLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_166setKrylovSchurLocking(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_lock);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_166setKrylovSchurLocking(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_lock) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setKrylovSchurLocking", 0);

  /* "SLEPc/EPS.pyx":1732
 *         non-locking variant).
 *         """
 *         cdef PetscBool val = asBool(lock)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurSetLocking(self.eps, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_lock); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 1732, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1733
 *         """
 *         cdef PetscBool val = asBool(lock)
 *         CHKERR( EPSKrylovSchurSetLocking(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getKrylovSchurLocking(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurSetLocking(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1733, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1715
 *         return toReal(val)
 * 
 *     def setKrylovSchurLocking(self, lock):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between locking and non-locking variants of the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setKrylovSchurLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1735
 *         CHKERR( EPSKrylovSchurSetLocking(self.eps, val) )
 * 
 *     def getKrylovSchurLocking(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the locking flag used in the Krylov-Schur method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_169getKrylovSchurLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_168getKrylovSchurLocking[] = "EPS.getKrylovSchurLocking(self)\n\n        Gets the locking flag used in the Krylov-Schur method.\n\n        Returns\n        -------\n        lock: bool\n              The locking flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_169getKrylovSchurLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getKrylovSchurLocking (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getKrylovSchurLocking", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getKrylovSchurLocking", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_168getKrylovSchurLocking(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_168getKrylovSchurLocking(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getKrylovSchurLocking", 0);

  /* "SLEPc/EPS.pyx":1744
 *               The locking flag.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurGetLocking(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":1745
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSKrylovSchurGetLocking(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurGetLocking(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1745, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1746
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSKrylovSchurGetLocking(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setKrylovSchurPartitions(self, npart):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 1746, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1735
 *         CHKERR( EPSKrylovSchurSetLocking(self.eps, val) )
 * 
 *     def getKrylovSchurLocking(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the locking flag used in the Krylov-Schur method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getKrylovSchurLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1748
 *         return toBool(tval)
 * 
 *     def setKrylovSchurPartitions(self, npart):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of partitions for the case of doing spectrum
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_171setKrylovSchurPartitions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_170setKrylovSchurPartitions[] = "EPS.setKrylovSchurPartitions(self, npart)\n\n        Sets the number of partitions for the case of doing spectrum\n        slicing for a computational interval with the communicator split\n        in several sub-communicators.\n\n        Parameters\n        ----------\n        npart: int\n              The number of partitions.\n\n        Notes\n        -----\n        By default, npart=1 so all processes in the communicator participate in\n        the processing of the whole interval. If npart>1 then the interval is\n        divided into npart subintervals, each of them being processed by a\n        subset of processes.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_171setKrylovSchurPartitions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_npart = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setKrylovSchurPartitions (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_npart,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_npart)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setKrylovSchurPartitions") < 0)) __PYX_ERR(17, 1748, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_npart = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setKrylovSchurPartitions", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1748, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setKrylovSchurPartitions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_170setKrylovSchurPartitions(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_npart);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_170setKrylovSchurPartitions(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_npart) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setKrylovSchurPartitions", 0);

  /* "SLEPc/EPS.pyx":1766
 *         subset of processes.
 *         """
 *         cdef PetscInt val = asInt(npart)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurSetPartitions(self.eps, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_npart); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 1766, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1767
 *         """
 *         cdef PetscInt val = asInt(npart)
 *         CHKERR( EPSKrylovSchurSetPartitions(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getKrylovSchurPartitions(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurSetPartitions(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1767, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1748
 *         return toBool(tval)
 * 
 *     def setKrylovSchurPartitions(self, npart):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of partitions for the case of doing spectrum
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setKrylovSchurPartitions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1769
 *         CHKERR( EPSKrylovSchurSetPartitions(self.eps, val) )
 * 
 *     def getKrylovSchurPartitions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of partitions of the communicator in case of
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_173getKrylovSchurPartitions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_172getKrylovSchurPartitions[] = "EPS.getKrylovSchurPartitions(self)\n\n        Gets the number of partitions of the communicator in case of\n        spectrum slicing.\n\n        Returns\n        -------\n        npart: int\n              The number of partitions.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_173getKrylovSchurPartitions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getKrylovSchurPartitions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getKrylovSchurPartitions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getKrylovSchurPartitions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_172getKrylovSchurPartitions(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_172getKrylovSchurPartitions(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getKrylovSchurPartitions", 0);

  /* "SLEPc/EPS.pyx":1779
 *               The number of partitions.
 *         """
 *         cdef PetscInt val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurGetPartitions(self.eps, &val) )
 *         return toInt(val)
 */
  __pyx_v_val = 0;

  /* "SLEPc/EPS.pyx":1780
 *         """
 *         cdef PetscInt val = 0
 *         CHKERR( EPSKrylovSchurGetPartitions(self.eps, &val) )             # <<<<<<<<<<<<<<
 *         return toInt(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurGetPartitions(__pyx_v_self->eps, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1780, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1781
 *         cdef PetscInt val = 0
 *         CHKERR( EPSKrylovSchurGetPartitions(self.eps, &val) )
 *         return toInt(val)             # <<<<<<<<<<<<<<
 * 
 *     def setKrylovSchurDetectZeros(self, detect):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 1781, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1769
 *         CHKERR( EPSKrylovSchurSetPartitions(self.eps, val) )
 * 
 *     def getKrylovSchurPartitions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of partitions of the communicator in case of
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getKrylovSchurPartitions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1783
 *         return toInt(val)
 * 
 *     def setKrylovSchurDetectZeros(self, detect):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to enforce detection of zeros during the factorizations
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_175setKrylovSchurDetectZeros(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_174setKrylovSchurDetectZeros[] = "EPS.setKrylovSchurDetectZeros(self, detect)\n\n        Sets a flag to enforce detection of zeros during the factorizations\n        throughout the spectrum slicing computation.\n\n        Parameters\n        ----------\n        detect: bool\n              True if zeros must checked for.\n\n        Notes\n        -----\n        A zero in the factorization indicates that a shift coincides with\n        an eigenvalue.\n\n        This flag is turned off by default, and may be necessary in some cases,\n        especially when several partitions are being used. This feature currently\n        requires an external package for factorizations with support for zero\n        detection, e.g. MUMPS.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_175setKrylovSchurDetectZeros(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_detect = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setKrylovSchurDetectZeros (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_detect,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_detect)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setKrylovSchurDetectZeros") < 0)) __PYX_ERR(17, 1783, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_detect = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setKrylovSchurDetectZeros", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1783, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setKrylovSchurDetectZeros", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_174setKrylovSchurDetectZeros(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_detect);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_174setKrylovSchurDetectZeros(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_detect) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setKrylovSchurDetectZeros", 0);

  /* "SLEPc/EPS.pyx":1803
 *         detection, e.g. MUMPS.
 *         """
 *         cdef PetscBool val = asBool(detect)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurSetDetectZeros(self.eps, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_detect); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 1803, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1804
 *         """
 *         cdef PetscBool val = asBool(detect)
 *         CHKERR( EPSKrylovSchurSetDetectZeros(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getKrylovSchurDetectZeros(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurSetDetectZeros(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1804, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1783
 *         return toInt(val)
 * 
 *     def setKrylovSchurDetectZeros(self, detect):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to enforce detection of zeros during the factorizations
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setKrylovSchurDetectZeros", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1806
 *         CHKERR( EPSKrylovSchurSetDetectZeros(self.eps, val) )
 * 
 *     def getKrylovSchurDetectZeros(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the flag that enforces zero detection in spectrum slicing.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_177getKrylovSchurDetectZeros(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_176getKrylovSchurDetectZeros[] = "EPS.getKrylovSchurDetectZeros(self)\n\n        Gets the flag that enforces zero detection in spectrum slicing.\n\n        Returns\n        -------\n        detect: bool\n              The zero detection flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_177getKrylovSchurDetectZeros(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getKrylovSchurDetectZeros (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getKrylovSchurDetectZeros", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getKrylovSchurDetectZeros", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_176getKrylovSchurDetectZeros(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_176getKrylovSchurDetectZeros(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getKrylovSchurDetectZeros", 0);

  /* "SLEPc/EPS.pyx":1815
 *               The zero detection flag.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurGetDetectZeros(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":1816
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSKrylovSchurGetDetectZeros(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurGetDetectZeros(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1816, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1817
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSKrylovSchurGetDetectZeros(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setKrylovSchurDimensions(self, nev=None, ncv=None, mpd=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 1817, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1806
 *         CHKERR( EPSKrylovSchurSetDetectZeros(self.eps, val) )
 * 
 *     def getKrylovSchurDetectZeros(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the flag that enforces zero detection in spectrum slicing.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getKrylovSchurDetectZeros", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1819
 *         return toBool(tval)
 * 
 *     def setKrylovSchurDimensions(self, nev=None, ncv=None, mpd=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the dimensions used for each subsolve step in case of doing
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_179setKrylovSchurDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_178setKrylovSchurDimensions[] = "EPS.setKrylovSchurDimensions(self, nev=None, ncv=None, mpd=None)\n\n        Sets the dimensions used for each subsolve step in case of doing\n        spectrum slicing for a computational interval. The meaning of the\n        parameters is the same as in `setDimensions()`.\n\n        Parameters\n        ----------\n        nev: int, optional\n             Number of eigenvalues to compute.\n        ncv: int, optional\n             Maximum dimension of the subspace to be used by the solver.\n        mpd: int, optional\n             Maximum dimension allowed for the projected problem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_179setKrylovSchurDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nev = 0;
  PyObject *__pyx_v_ncv = 0;
  PyObject *__pyx_v_mpd = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setKrylovSchurDimensions (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nev,&__pyx_n_s_ncv,&__pyx_n_s_mpd,0};
    PyObject* values[3] = {0,0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nev);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ncv);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mpd);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setKrylovSchurDimensions") < 0)) __PYX_ERR(17, 1819, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_nev = values[0];
    __pyx_v_ncv = values[1];
    __pyx_v_mpd = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setKrylovSchurDimensions", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1819, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setKrylovSchurDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_178setKrylovSchurDimensions(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_nev, __pyx_v_ncv, __pyx_v_mpd);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_178setKrylovSchurDimensions(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_nev, PyObject *__pyx_v_ncv, PyObject *__pyx_v_mpd) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setKrylovSchurDimensions", 0);

  /* "SLEPc/EPS.pyx":1834
 *              Maximum dimension allowed for the projected problem.
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":1835
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":1836
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)
 */
  __pyx_v_ival3 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":1837
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)             # <<<<<<<<<<<<<<
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)
 */
  __pyx_t_1 = (__pyx_v_nev != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_nev); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 1837, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":1838
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)             # <<<<<<<<<<<<<<
 *         if mpd is not None: ival3 = asInt(mpd)
 *         CHKERR( EPSKrylovSchurSetDimensions(self.eps, ival1, ival2, ival3) )
 */
  __pyx_t_2 = (__pyx_v_ncv != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_ncv); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 1838, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":1839
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurSetDimensions(self.eps, ival1, ival2, ival3) )
 * 
 */
  __pyx_t_1 = (__pyx_v_mpd != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_mpd); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 1839, __pyx_L1_error)
    __pyx_v_ival3 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":1840
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)
 *         CHKERR( EPSKrylovSchurSetDimensions(self.eps, ival1, ival2, ival3) )             # <<<<<<<<<<<<<<
 * 
 *     def getKrylovSchurDimensions(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurSetDimensions(__pyx_v_self->eps, __pyx_v_ival1, __pyx_v_ival2, __pyx_v_ival3)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(17, 1840, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1819
 *         return toBool(tval)
 * 
 *     def setKrylovSchurDimensions(self, nev=None, ncv=None, mpd=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the dimensions used for each subsolve step in case of doing
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setKrylovSchurDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1842
 *         CHKERR( EPSKrylovSchurSetDimensions(self.eps, ival1, ival2, ival3) )
 * 
 *     def getKrylovSchurDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the dimensions used for each subsolve step in case of doing
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_181getKrylovSchurDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_180getKrylovSchurDimensions[] = "EPS.getKrylovSchurDimensions(self)\n\n        Gets the dimensions used for each subsolve step in case of doing\n        spectrum slicing for a computational interval.\n\n        Returns\n        -------\n        nev: int\n             Number of eigenvalues to compute.\n        ncv: int\n             Maximum dimension of the subspace to be used by the solver.\n        mpd: int\n             Maximum dimension allowed for the projected problem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_181getKrylovSchurDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getKrylovSchurDimensions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getKrylovSchurDimensions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getKrylovSchurDimensions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_180getKrylovSchurDimensions(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_180getKrylovSchurDimensions(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getKrylovSchurDimensions", 0);

  /* "SLEPc/EPS.pyx":1856
 *              Maximum dimension allowed for the projected problem.
 *         """
 *         cdef PetscInt ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/EPS.pyx":1857
 *         """
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival3 = 0
 *         CHKERR( EPSKrylovSchurGetDimensions(self.eps, &ival1, &ival2, &ival3) )
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/EPS.pyx":1858
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurGetDimensions(self.eps, &ival1, &ival2, &ival3) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 */
  __pyx_v_ival3 = 0;

  /* "SLEPc/EPS.pyx":1859
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 *         CHKERR( EPSKrylovSchurGetDimensions(self.eps, &ival1, &ival2, &ival3) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurGetDimensions(__pyx_v_self->eps, (&__pyx_v_ival1), (&__pyx_v_ival2), (&__pyx_v_ival3))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 1859, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1860
 *         cdef PetscInt ival3 = 0
 *         CHKERR( EPSKrylovSchurGetDimensions(self.eps, &ival1, &ival2, &ival3) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))             # <<<<<<<<<<<<<<
 * 
 *     def getKrylovSchurSubcommInfo(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 1860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival3); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 1860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(17, 1860, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1842
 *         CHKERR( EPSKrylovSchurSetDimensions(self.eps, ival1, ival2, ival3) )
 * 
 *     def getKrylovSchurDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the dimensions used for each subsolve step in case of doing
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getKrylovSchurDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1862
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 *     def getKrylovSchurSubcommInfo(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets information related to the case of doing spectrum slicing
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_183getKrylovSchurSubcommInfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_182getKrylovSchurSubcommInfo[] = "EPS.getKrylovSchurSubcommInfo(self)\n\n        Gets information related to the case of doing spectrum slicing\n        for a computational interval with multiple communicators.\n\n        Returns\n        -------\n        k: int\n             Number of the subinterval for the calling process.\n        n: int\n             Number of eigenvalues found in the k-th subinterval.\n        v: Vec\n             A vector owned by processes in the subcommunicator with dimensions\n             compatible for locally computed eigenvectors.\n\n        Notes\n        -----\n        This function is only available for spectrum slicing runs.\n\n        The returned Vec should be destroyed by the user.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_183getKrylovSchurSubcommInfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getKrylovSchurSubcommInfo (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getKrylovSchurSubcommInfo", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getKrylovSchurSubcommInfo", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_182getKrylovSchurSubcommInfo(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_182getKrylovSchurSubcommInfo(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  struct PyPetscVecObject *__pyx_v_vec = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getKrylovSchurSubcommInfo", 0);

  /* "SLEPc/EPS.pyx":1883
 *         The returned Vec should be destroyed by the user.
 *         """
 *         cdef PetscInt ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         cdef Vec vec = Vec()
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/EPS.pyx":1884
 *         """
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         cdef Vec vec = Vec()
 *         CHKERR( EPSKrylovSchurGetSubcommInfo(self.eps, &ival1, &ival2, &vec.vec) )
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/EPS.pyx":1885
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0
 *         cdef Vec vec = Vec()             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurGetSubcommInfo(self.eps, &ival1, &ival2, &vec.vec) )
 *         return (toInt(ival1), toInt(ival2), vec)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Vec)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1885, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_vec = ((struct PyPetscVecObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":1886
 *         cdef PetscInt ival2 = 0
 *         cdef Vec vec = Vec()
 *         CHKERR( EPSKrylovSchurGetSubcommInfo(self.eps, &ival1, &ival2, &vec.vec) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2), vec)
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurGetSubcommInfo(__pyx_v_self->eps, (&__pyx_v_ival1), (&__pyx_v_ival2), (&__pyx_v_vec->vec))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1886, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1887
 *         cdef Vec vec = Vec()
 *         CHKERR( EPSKrylovSchurGetSubcommInfo(self.eps, &ival1, &ival2, &vec.vec) )
 *         return (toInt(ival1), toInt(ival2), vec)             # <<<<<<<<<<<<<<
 * 
 *     def getKrylovSchurSubcommPairs(self, int i, Vec V):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1887, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 1887, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 1887, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __Pyx_INCREF(((PyObject *)__pyx_v_vec));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_vec));
  PyTuple_SET_ITEM(__pyx_t_4, 2, ((PyObject *)__pyx_v_vec));
  __pyx_t_1 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1862
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 *     def getKrylovSchurSubcommInfo(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets information related to the case of doing spectrum slicing
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getKrylovSchurSubcommInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_vec);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1889
 *         return (toInt(ival1), toInt(ival2), vec)
 * 
 *     def getKrylovSchurSubcommPairs(self, int i, Vec V):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th eigenpair stored internally in the multi-communicator
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_185getKrylovSchurSubcommPairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_184getKrylovSchurSubcommPairs[] = "EPS.getKrylovSchurSubcommPairs(self, int i, Vec V)\n\n        Gets the i-th eigenpair stored internally in the multi-communicator\n        to which the calling process belongs.\n\n        Parameters\n        ----------\n        i: int\n           Index of the solution to be obtained.\n        V: Vec\n           Placeholder for the returned eigenvector.\n\n        Returns\n        -------\n        e: scalar\n           The computed eigenvalue.\n\n        Notes\n        -----\n        The index ``i`` should be a value between ``0`` and ``n-1``,\n        where ``n`` is the number of vectors in the local subinterval,\n        see `getKrylovSchurSubcommInfo()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_185getKrylovSchurSubcommPairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  struct PyPetscVecObject *__pyx_v_V = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getKrylovSchurSubcommPairs (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,&__pyx_n_s_V,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_V)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("getKrylovSchurSubcommPairs", 1, 2, 2, 1); __PYX_ERR(17, 1889, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getKrylovSchurSubcommPairs") < 0)) __PYX_ERR(17, 1889, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(17, 1889, __pyx_L3_error)
    __pyx_v_V = ((struct PyPetscVecObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getKrylovSchurSubcommPairs", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1889, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getKrylovSchurSubcommPairs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_V), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "V", 0))) __PYX_ERR(17, 1889, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_184getKrylovSchurSubcommPairs(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_i, __pyx_v_V);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_184getKrylovSchurSubcommPairs(struct PySlepcEPSObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_V) {
  PetscScalar __pyx_v_sval;
  Vec __pyx_v_vec;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Vec __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getKrylovSchurSubcommPairs", 0);

  /* "SLEPc/EPS.pyx":1912
 *         see `getKrylovSchurSubcommInfo()`.
 *         """
 *         cdef PetscScalar sval = 0             # <<<<<<<<<<<<<<
 *         cdef PetscVec vec = V.vec if V is not None else <PetscVec>NULL
 *         CHKERR( EPSKrylovSchurGetSubcommPairs(self.eps, i, &sval, vec) )
 */
  __pyx_v_sval = 0.0;

  /* "SLEPc/EPS.pyx":1913
 *         """
 *         cdef PetscScalar sval = 0
 *         cdef PetscVec vec = V.vec if V is not None else <PetscVec>NULL             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurGetSubcommPairs(self.eps, i, &sval, vec) )
 *         return toScalar(sval)
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_V) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_V->vec;
  } else {
    __pyx_t_1 = ((Vec)NULL);
  }
  __pyx_v_vec = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1914
 *         cdef PetscScalar sval = 0
 *         cdef PetscVec vec = V.vec if V is not None else <PetscVec>NULL
 *         CHKERR( EPSKrylovSchurGetSubcommPairs(self.eps, i, &sval, vec) )             # <<<<<<<<<<<<<<
 *         return toScalar(sval)
 * 
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurGetSubcommPairs(__pyx_v_self->eps, __pyx_v_i, (&__pyx_v_sval), __pyx_v_vec)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(17, 1914, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1915
 *         cdef PetscVec vec = V.vec if V is not None else <PetscVec>NULL
 *         CHKERR( EPSKrylovSchurGetSubcommPairs(self.eps, i, &sval, vec) )
 *         return toScalar(sval)             # <<<<<<<<<<<<<<
 * 
 *     def getKrylovSchurSubcommMats(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_sval); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 1915, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1889
 *         return (toInt(ival1), toInt(ival2), vec)
 * 
 *     def getKrylovSchurSubcommPairs(self, int i, Vec V):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th eigenpair stored internally in the multi-communicator
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getKrylovSchurSubcommPairs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1917
 *         return toScalar(sval)
 * 
 *     def getKrylovSchurSubcommMats(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the eigenproblem matrices stored internally in the subcommunicator
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_187getKrylovSchurSubcommMats(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_186getKrylovSchurSubcommMats[] = "EPS.getKrylovSchurSubcommMats(self)\n\n        Gets the eigenproblem matrices stored internally in the subcommunicator\n        to which the calling process belongs.\n\n        Returns\n        -------\n        A: Mat\n           The matrix associated with the eigensystem.\n        B: Mat\n           The second matrix in the case of generalized eigenproblems.\n\n        Notes\n        -----\n        This is the analog of `getOperators()`, but returns the matrices distributed\n        differently (in the subcommunicator rather than in the parent communicator).\n\n        These matrices should not be modified by the user.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_187getKrylovSchurSubcommMats(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getKrylovSchurSubcommMats (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getKrylovSchurSubcommMats", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getKrylovSchurSubcommMats", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_186getKrylovSchurSubcommMats(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_186getKrylovSchurSubcommMats(struct PySlepcEPSObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  struct PyPetscMatObject *__pyx_v_B = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getKrylovSchurSubcommMats", 0);

  /* "SLEPc/EPS.pyx":1936
 *         These matrices should not be modified by the user.
 *         """
 *         cdef Mat A = Mat()             # <<<<<<<<<<<<<<
 *         cdef Mat B = Mat()
 *         CHKERR( EPSKrylovSchurGetSubcommMats(self.eps, &A.mat, &B.mat) )
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1936, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_A = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":1937
 *         """
 *         cdef Mat A = Mat()
 *         cdef Mat B = Mat()             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurGetSubcommMats(self.eps, &A.mat, &B.mat) )
 *         PetscINCREF(A.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1937, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_B = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":1938
 *         cdef Mat A = Mat()
 *         cdef Mat B = Mat()
 *         CHKERR( EPSKrylovSchurGetSubcommMats(self.eps, &A.mat, &B.mat) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(A.obj)
 *         PetscINCREF(B.obj)
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurGetSubcommMats(__pyx_v_self->eps, (&__pyx_v_A->mat), (&__pyx_v_B->mat))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 1938, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1939
 *         cdef Mat B = Mat()
 *         CHKERR( EPSKrylovSchurGetSubcommMats(self.eps, &A.mat, &B.mat) )
 *         PetscINCREF(A.obj)             # <<<<<<<<<<<<<<
 *         PetscINCREF(B.obj)
 *         return (A, B)
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_A->__pyx_base.obj));

  /* "SLEPc/EPS.pyx":1940
 *         CHKERR( EPSKrylovSchurGetSubcommMats(self.eps, &A.mat, &B.mat) )
 *         PetscINCREF(A.obj)
 *         PetscINCREF(B.obj)             # <<<<<<<<<<<<<<
 *         return (A, B)
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_B->__pyx_base.obj));

  /* "SLEPc/EPS.pyx":1941
 *         PetscINCREF(A.obj)
 *         PetscINCREF(B.obj)
 *         return (A, B)             # <<<<<<<<<<<<<<
 * 
 *     def updateKrylovSchurSubcommMats(self, s=1.0, a=1.0, Mat Au=None,
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 1941, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(((PyObject *)__pyx_v_A));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_A));
  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_A));
  __Pyx_INCREF(((PyObject *)__pyx_v_B));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_B));
  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_B));
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":1917
 *         return toScalar(sval)
 * 
 *     def getKrylovSchurSubcommMats(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the eigenproblem matrices stored internally in the subcommunicator
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getKrylovSchurSubcommMats", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_A);
  __Pyx_XDECREF((PyObject *)__pyx_v_B);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1943
 *         return (A, B)
 * 
 *     def updateKrylovSchurSubcommMats(self, s=1.0, a=1.0, Mat Au=None,             # <<<<<<<<<<<<<<
 *                                      t=1.0, b=1.0, Mat Bu=None,
 *                                      structure=None, globalup=False):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_189updateKrylovSchurSubcommMats(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_188updateKrylovSchurSubcommMats[] = "EPS.updateKrylovSchurSubcommMats(self, s=1.0, a=1.0, Mat Au=None, t=1.0, b=1.0, Mat Bu=None, structure=None, globalup=False)\n\n        Update the eigenproblem matrices stored internally in the\n        subcommunicator to which the calling process belongs.\n\n        Parameters\n        ----------\n        s: float (real or complex)\n           Scalar that multiplies the existing A matrix.\n        a: float (real or complex)\n           Scalar used in the axpy operation on A.\n        Au: Mat, optional\n           The matrix used in the axpy operation on A.\n        t: float (real or complex)\n           Scalar that multiplies the existing B matrix.\n        b: float (real or complex)\n           Scalar used in the axpy operation on B.\n        Bu: Mat, optional\n           The matrix used in the axpy operation on B.\n        structure: `PETSc.Mat.Structure` enumerate\n           Either same, different, or a subset of the non-zero sparsity pattern.\n        globalup: bool\n           Whether global matrices must be updated or not.\n\n        Notes\n        -----\n        This function modifies the eigenproblem matrices at\n        subcommunicator level, and optionally updates the global\n        matrices in the parent communicator.  The updates are\n        expressed as ``A <-- s*A + a*Au``, ``B <-- t*B + b*Bu``.\n\n        It is possible to update one of the matrices, or both.\n\n        The matrices `Au` and `Bu` must be equal in all subcommunicators.\n\n        The `structure` flag is passed to the `PETSc.Mat.axpy()` operations\n        to perform the updates.\n\n        If `globalup` is True, communication is carried out to\n        reconstruct the updated matrices in the parent communicator.\n\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_189updateKrylovSchurSubcommMats(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_s = 0;
  PyObject *__pyx_v_a = 0;
  struct PyPetscMatObject *__pyx_v_Au = 0;
  PyObject *__pyx_v_t = 0;
  PyObject *__pyx_v_b = 0;
  struct PyPetscMatObject *__pyx_v_Bu = 0;
  PyObject *__pyx_v_structure = 0;
  PyObject *__pyx_v_globalup = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("updateKrylovSchurSubcommMats (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_s,&__pyx_n_s_a,&__pyx_n_s_Au,&__pyx_n_s_t,&__pyx_n_s_b,&__pyx_n_s_Bu,&__pyx_n_s_structure,&__pyx_n_s_globalup,0};
    PyObject* values[8] = {0,0,0,0,0,0,0,0};
    values[0] = ((PyObject *)__pyx_float_1_0);
    values[1] = ((PyObject *)__pyx_float_1_0);
    values[2] = (PyObject *)((struct PyPetscMatObject *)Py_None);
    values[3] = ((PyObject *)__pyx_float_1_0);
    values[4] = ((PyObject *)__pyx_float_1_0);

    /* "SLEPc/EPS.pyx":1944
 * 
 *     def updateKrylovSchurSubcommMats(self, s=1.0, a=1.0, Mat Au=None,
 *                                      t=1.0, b=1.0, Mat Bu=None,             # <<<<<<<<<<<<<<
 *                                      structure=None, globalup=False):
 *         """
 */
    values[5] = (PyObject *)((struct PyPetscMatObject *)Py_None);

    /* "SLEPc/EPS.pyx":1945
 *     def updateKrylovSchurSubcommMats(self, s=1.0, a=1.0, Mat Au=None,
 *                                      t=1.0, b=1.0, Mat Bu=None,
 *                                      structure=None, globalup=False):             # <<<<<<<<<<<<<<
 *         """
 *         Update the eigenproblem matrices stored internally in the
 */
    values[6] = ((PyObject *)Py_None);
    values[7] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_s);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_a);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Au);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_t);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_b);
          if (value) { values[4] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Bu);
          if (value) { values[5] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  6:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_structure);
          if (value) { values[6] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  7:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_globalup);
          if (value) { values[7] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "updateKrylovSchurSubcommMats") < 0)) __PYX_ERR(17, 1943, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_s = values[0];
    __pyx_v_a = values[1];
    __pyx_v_Au = ((struct PyPetscMatObject *)values[2]);
    __pyx_v_t = values[3];
    __pyx_v_b = values[4];
    __pyx_v_Bu = ((struct PyPetscMatObject *)values[5]);
    __pyx_v_structure = values[6];
    __pyx_v_globalup = values[7];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("updateKrylovSchurSubcommMats", 0, 0, 8, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1943, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.updateKrylovSchurSubcommMats", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Au), __pyx_ptype_8petsc4py_5PETSc_Mat, 1, "Au", 0))) __PYX_ERR(17, 1943, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Bu), __pyx_ptype_8petsc4py_5PETSc_Mat, 1, "Bu", 0))) __PYX_ERR(17, 1944, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_188updateKrylovSchurSubcommMats(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_s, __pyx_v_a, __pyx_v_Au, __pyx_v_t, __pyx_v_b, __pyx_v_Bu, __pyx_v_structure, __pyx_v_globalup);

  /* "SLEPc/EPS.pyx":1943
 *         return (A, B)
 * 
 *     def updateKrylovSchurSubcommMats(self, s=1.0, a=1.0, Mat Au=None,             # <<<<<<<<<<<<<<
 *                                      t=1.0, b=1.0, Mat Bu=None,
 *                                      structure=None, globalup=False):
 */

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_188updateKrylovSchurSubcommMats(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_s, PyObject *__pyx_v_a, struct PyPetscMatObject *__pyx_v_Au, PyObject *__pyx_v_t, PyObject *__pyx_v_b, struct PyPetscMatObject *__pyx_v_Bu, PyObject *__pyx_v_structure, PyObject *__pyx_v_globalup) {
  Mat __pyx_v_Amat;
  Mat __pyx_v_Bmat;
  MatStructure __pyx_v_vstr;
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Mat __pyx_t_1;
  int __pyx_t_2;
  MatStructure __pyx_t_3;
  PetscBool __pyx_t_4;
  PetscScalar __pyx_t_5;
  PetscScalar __pyx_t_6;
  PetscScalar __pyx_t_7;
  PetscScalar __pyx_t_8;
  int __pyx_t_9;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("updateKrylovSchurSubcommMats", 0);

  /* "SLEPc/EPS.pyx":1987
 * 
 *         """
 *         cdef PetscMat Amat = Au.mat if Au is not None else <PetscMat>NULL             # <<<<<<<<<<<<<<
 *         cdef PetscMat Bmat = Bu.mat if Bu is not None else <PetscMat>NULL
 *         cdef PetscMatStructure vstr = matstructure(structure)
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_Au) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_Au->mat;
  } else {
    __pyx_t_1 = ((Mat)NULL);
  }
  __pyx_v_Amat = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1988
 *         """
 *         cdef PetscMat Amat = Au.mat if Au is not None else <PetscMat>NULL
 *         cdef PetscMat Bmat = Bu.mat if Bu is not None else <PetscMat>NULL             # <<<<<<<<<<<<<<
 *         cdef PetscMatStructure vstr = matstructure(structure)
 *         cdef PetscBool tval = globalup
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_Bu) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_Bu->mat;
  } else {
    __pyx_t_1 = ((Mat)NULL);
  }
  __pyx_v_Bmat = __pyx_t_1;

  /* "SLEPc/EPS.pyx":1989
 *         cdef PetscMat Amat = Au.mat if Au is not None else <PetscMat>NULL
 *         cdef PetscMat Bmat = Bu.mat if Bu is not None else <PetscMat>NULL
 *         cdef PetscMatStructure vstr = matstructure(structure)             # <<<<<<<<<<<<<<
 *         cdef PetscBool tval = globalup
 *         CHKERR( EPSKrylovSchurUpdateSubcommMats(self.eps, s, a, Amat, t, b, Bmat, vstr, tval) )
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_matstructure(__pyx_v_structure); if (unlikely(__pyx_t_3 == ((MatStructure)((MatStructure)-1L)))) __PYX_ERR(17, 1989, __pyx_L1_error)
  __pyx_v_vstr = __pyx_t_3;

  /* "SLEPc/EPS.pyx":1990
 *         cdef PetscMat Bmat = Bu.mat if Bu is not None else <PetscMat>NULL
 *         cdef PetscMatStructure vstr = matstructure(structure)
 *         cdef PetscBool tval = globalup             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurUpdateSubcommMats(self.eps, s, a, Amat, t, b, Bmat, vstr, tval) )
 * 
 */
  __pyx_t_4 = ((PetscBool)__Pyx_PyInt_As_PetscBool(__pyx_v_globalup)); if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 1990, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_4;

  /* "SLEPc/EPS.pyx":1991
 *         cdef PetscMatStructure vstr = matstructure(structure)
 *         cdef PetscBool tval = globalup
 *         CHKERR( EPSKrylovSchurUpdateSubcommMats(self.eps, s, a, Amat, t, b, Bmat, vstr, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def setKrylovSchurSubintervals(self, subint):
 */
  __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_v_s); if (unlikely((__pyx_t_5 == ((PetscScalar)-1)) && PyErr_Occurred())) __PYX_ERR(17, 1991, __pyx_L1_error)
  __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_v_a); if (unlikely((__pyx_t_6 == ((PetscScalar)-1)) && PyErr_Occurred())) __PYX_ERR(17, 1991, __pyx_L1_error)
  __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_v_t); if (unlikely((__pyx_t_7 == ((PetscScalar)-1)) && PyErr_Occurred())) __PYX_ERR(17, 1991, __pyx_L1_error)
  __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_v_b); if (unlikely((__pyx_t_8 == ((PetscScalar)-1)) && PyErr_Occurred())) __PYX_ERR(17, 1991, __pyx_L1_error)
  __pyx_t_9 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurUpdateSubcommMats(__pyx_v_self->eps, __pyx_t_5, __pyx_t_6, __pyx_v_Amat, __pyx_t_7, __pyx_t_8, __pyx_v_Bmat, __pyx_v_vstr, __pyx_v_tval)); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(17, 1991, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1943
 *         return (A, B)
 * 
 *     def updateKrylovSchurSubcommMats(self, s=1.0, a=1.0, Mat Au=None,             # <<<<<<<<<<<<<<
 *                                      t=1.0, b=1.0, Mat Bu=None,
 *                                      structure=None, globalup=False):
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.updateKrylovSchurSubcommMats", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":1993
 *         CHKERR( EPSKrylovSchurUpdateSubcommMats(self.eps, s, a, Amat, t, b, Bmat, vstr, tval) )
 * 
 *     def setKrylovSchurSubintervals(self, subint):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the subinterval boundaries for spectrum slicing with a computational interval.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_191setKrylovSchurSubintervals(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_190setKrylovSchurSubintervals[] = "EPS.setKrylovSchurSubintervals(self, subint)\n\n        Sets the subinterval boundaries for spectrum slicing with a computational interval.\n\n        Parameters\n        ----------\n        subint: list of float\n            Real values specifying subintervals\n\n        Notes\n        -----\n        Logically Collective on EPS\n        This function must be called after setKrylovSchurPartitions().\n        For npart partitions, the argument subint must contain npart+1\n        real values sorted in ascending order:\n        subint_0, subint_1, ..., subint_npart,\n        where the first and last values must coincide with the interval\n        endpoints set with EPSSetInterval().\n        The subintervals are then defined by two consecutive points:\n        [subint_0,subint_1], [subint_1,subint_2], and so on.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_191setKrylovSchurSubintervals(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_subint = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setKrylovSchurSubintervals (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_subint,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_subint)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setKrylovSchurSubintervals") < 0)) __PYX_ERR(17, 1993, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_subint = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setKrylovSchurSubintervals", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 1993, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setKrylovSchurSubintervals", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_190setKrylovSchurSubintervals(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_subint);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_190setKrylovSchurSubintervals(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_subint) {
  PetscBool __pyx_v_match;
  PetscReal *__pyx_v_subintarray;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_n;
  PetscInt __pyx_v_nparts;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  Py_ssize_t __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  Py_ssize_t __pyx_t_5;
  Py_ssize_t __pyx_t_6;
  PetscReal __pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setKrylovSchurSubintervals", 0);

  /* "SLEPc/EPS.pyx":2014
 *         [subint_0,subint_1], [subint_1,subint_2], and so on.
 *         """
 *         cdef PetscBool match = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( PetscObjectTypeCompare(<PetscObject>self.eps, EPSKRYLOVSCHUR, &match) )
 *         if match == PETSC_FALSE: return
 */
  __pyx_v_match = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":2015
 *         """
 *         cdef PetscBool match = PETSC_FALSE
 *         CHKERR( PetscObjectTypeCompare(<PetscObject>self.eps, EPSKRYLOVSCHUR, &match) )             # <<<<<<<<<<<<<<
 *         if match == PETSC_FALSE: return
 *         cdef PetscReal *subintarray = NULL
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscObjectTypeCompare(((PetscObject)__pyx_v_self->eps), EPSKRYLOVSCHUR, (&__pyx_v_match))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2015, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2016
 *         cdef PetscBool match = PETSC_FALSE
 *         CHKERR( PetscObjectTypeCompare(<PetscObject>self.eps, EPSKRYLOVSCHUR, &match) )
 *         if match == PETSC_FALSE: return             # <<<<<<<<<<<<<<
 *         cdef PetscReal *subintarray = NULL
 *         cdef Py_ssize_t i = 0, n = len(subint)
 */
  __pyx_t_2 = ((__pyx_v_match == PETSC_FALSE) != 0);
  if (__pyx_t_2) {
    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;
  }

  /* "SLEPc/EPS.pyx":2017
 *         CHKERR( PetscObjectTypeCompare(<PetscObject>self.eps, EPSKRYLOVSCHUR, &match) )
 *         if match == PETSC_FALSE: return
 *         cdef PetscReal *subintarray = NULL             # <<<<<<<<<<<<<<
 *         cdef Py_ssize_t i = 0, n = len(subint)
 *         cdef PetscInt nparts = 0
 */
  __pyx_v_subintarray = NULL;

  /* "SLEPc/EPS.pyx":2018
 *         if match == PETSC_FALSE: return
 *         cdef PetscReal *subintarray = NULL
 *         cdef Py_ssize_t i = 0, n = len(subint)             # <<<<<<<<<<<<<<
 *         cdef PetscInt nparts = 0
 *         CHKERR( EPSKrylovSchurGetPartitions(self.eps, &nparts) )
 */
  __pyx_v_i = 0;
  __pyx_t_3 = PyObject_Length(__pyx_v_subint); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(17, 2018, __pyx_L1_error)
  __pyx_v_n = __pyx_t_3;

  /* "SLEPc/EPS.pyx":2019
 *         cdef PetscReal *subintarray = NULL
 *         cdef Py_ssize_t i = 0, n = len(subint)
 *         cdef PetscInt nparts = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurGetPartitions(self.eps, &nparts) )
 *         assert n >= nparts
 */
  __pyx_v_nparts = 0;

  /* "SLEPc/EPS.pyx":2020
 *         cdef Py_ssize_t i = 0, n = len(subint)
 *         cdef PetscInt nparts = 0
 *         CHKERR( EPSKrylovSchurGetPartitions(self.eps, &nparts) )             # <<<<<<<<<<<<<<
 *         assert n >= nparts
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscReal),<void**>&subintarray)
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurGetPartitions(__pyx_v_self->eps, (&__pyx_v_nparts))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2020, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2021
 *         cdef PetscInt nparts = 0
 *         CHKERR( EPSKrylovSchurGetPartitions(self.eps, &nparts) )
 *         assert n >= nparts             # <<<<<<<<<<<<<<
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscReal),<void**>&subintarray)
 *         for i in range(n): subintarray[i] = asReal(subint[i])
 */
  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(!Py_OptimizeFlag)) {
    if (unlikely(!((__pyx_v_n >= __pyx_v_nparts) != 0))) {
      PyErr_SetNone(PyExc_AssertionError);
      __PYX_ERR(17, 2021, __pyx_L1_error)
    }
  }
  #endif

  /* "SLEPc/EPS.pyx":2022
 *         CHKERR( EPSKrylovSchurGetPartitions(self.eps, &nparts) )
 *         assert n >= nparts
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscReal),<void**>&subintarray)             # <<<<<<<<<<<<<<
 *         for i in range(n): subintarray[i] = asReal(subint[i])
 *         CHKERR( EPSKrylovSchurSetSubintervals(self.eps, subintarray) )
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_n) * (sizeof(PetscReal))), ((void **)(&__pyx_v_subintarray))); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 2022, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_v_tmp = __pyx_t_4;
  __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":2023
 *         assert n >= nparts
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscReal),<void**>&subintarray)
 *         for i in range(n): subintarray[i] = asReal(subint[i])             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurSetSubintervals(self.eps, subintarray) )
 * 
 */
  __pyx_t_3 = __pyx_v_n;
  __pyx_t_5 = __pyx_t_3;
  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
    __pyx_v_i = __pyx_t_6;
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_subint, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 2023, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_t_4); if (unlikely(__pyx_t_7 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(17, 2023, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    (__pyx_v_subintarray[__pyx_v_i]) = __pyx_t_7;
  }

  /* "SLEPc/EPS.pyx":2024
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscReal),<void**>&subintarray)
 *         for i in range(n): subintarray[i] = asReal(subint[i])
 *         CHKERR( EPSKrylovSchurSetSubintervals(self.eps, subintarray) )             # <<<<<<<<<<<<<<
 * 
 *     def getKrylovSchurSubintervals(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurSetSubintervals(__pyx_v_self->eps, __pyx_v_subintarray)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2024, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":1993
 *         CHKERR( EPSKrylovSchurUpdateSubcommMats(self.eps, s, a, Amat, t, b, Bmat, vstr, tval) )
 * 
 *     def setKrylovSchurSubintervals(self, subint):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the subinterval boundaries for spectrum slicing with a computational interval.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setKrylovSchurSubintervals", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2026
 *         CHKERR( EPSKrylovSchurSetSubintervals(self.eps, subintarray) )
 * 
 *     def getKrylovSchurSubintervals(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the points that delimit the subintervals used
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_193getKrylovSchurSubintervals(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_192getKrylovSchurSubintervals[] = "EPS.getKrylovSchurSubintervals(self)\n\n        Returns the points that delimit the subintervals used\n        in spectrum slicing with several partitions.\n\n        Returns\n        -------\n        subint: list of float\n            Real values specifying subintervals\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_193getKrylovSchurSubintervals(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getKrylovSchurSubintervals (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getKrylovSchurSubintervals", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getKrylovSchurSubintervals", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_192getKrylovSchurSubintervals(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_192getKrylovSchurSubintervals(struct PySlepcEPSObject *__pyx_v_self) {
  PetscReal *__pyx_v_subintarray;
  PetscInt __pyx_v_nparts;
  PyObject *__pyx_v_subint = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  char const *__pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  PyObject *__pyx_t_10 = NULL;
  int __pyx_t_11;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getKrylovSchurSubintervals", 0);

  /* "SLEPc/EPS.pyx":2036
 *             Real values specifying subintervals
 *         """
 *         cdef PetscReal *subintarray = NULL             # <<<<<<<<<<<<<<
 *         cdef PetscInt nparts = 0
 *         CHKERR( EPSKrylovSchurGetPartitions(self.eps, &nparts) )
 */
  __pyx_v_subintarray = NULL;

  /* "SLEPc/EPS.pyx":2037
 *         """
 *         cdef PetscReal *subintarray = NULL
 *         cdef PetscInt nparts = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurGetPartitions(self.eps, &nparts) )
 *         CHKERR( EPSKrylovSchurGetSubintervals(self.eps, &subintarray) )
 */
  __pyx_v_nparts = 0;

  /* "SLEPc/EPS.pyx":2038
 *         cdef PetscReal *subintarray = NULL
 *         cdef PetscInt nparts = 0
 *         CHKERR( EPSKrylovSchurGetPartitions(self.eps, &nparts) )             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurGetSubintervals(self.eps, &subintarray) )
 *         cdef object subint = None
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurGetPartitions(__pyx_v_self->eps, (&__pyx_v_nparts))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2038, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2039
 *         cdef PetscInt nparts = 0
 *         CHKERR( EPSKrylovSchurGetPartitions(self.eps, &nparts) )
 *         CHKERR( EPSKrylovSchurGetSubintervals(self.eps, &subintarray) )             # <<<<<<<<<<<<<<
 *         cdef object subint = None
 *         try:
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurGetSubintervals(__pyx_v_self->eps, (&__pyx_v_subintarray))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2039, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2040
 *         CHKERR( EPSKrylovSchurGetPartitions(self.eps, &nparts) )
 *         CHKERR( EPSKrylovSchurGetSubintervals(self.eps, &subintarray) )
 *         cdef object subint = None             # <<<<<<<<<<<<<<
 *         try:
 *             subint = array_r(nparts+1, subintarray)
 */
  __Pyx_INCREF(Py_None);
  __pyx_v_subint = Py_None;

  /* "SLEPc/EPS.pyx":2041
 *         CHKERR( EPSKrylovSchurGetSubintervals(self.eps, &subintarray) )
 *         cdef object subint = None
 *         try:             # <<<<<<<<<<<<<<
 *             subint = array_r(nparts+1, subintarray)
 *         finally:
 */
  /*try:*/ {

    /* "SLEPc/EPS.pyx":2042
 *         cdef object subint = None
 *         try:
 *             subint = array_r(nparts+1, subintarray)             # <<<<<<<<<<<<<<
 *         finally:
 *             CHKERR( PetscFree(subintarray) )
 */
    __pyx_t_2 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_r((__pyx_v_nparts + 1), __pyx_v_subintarray)); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2042, __pyx_L4_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_subint, __pyx_t_2);
    __pyx_t_2 = 0;
  }

  /* "SLEPc/EPS.pyx":2044
 *             subint = array_r(nparts+1, subintarray)
 *         finally:
 *             CHKERR( PetscFree(subintarray) )             # <<<<<<<<<<<<<<
 *         return subint
 * 
 */
  /*finally:*/ {
    /*normal exit:*/{
      __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_subintarray)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2044, __pyx_L1_error)
      goto __pyx_L5;
    }
    __pyx_L4_error:;
    /*exception exit:*/{
      __Pyx_PyThreadState_declare
      __Pyx_PyThreadState_assign
      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_5);
      __Pyx_XGOTREF(__pyx_t_6);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_8);
      __Pyx_XGOTREF(__pyx_t_9);
      __Pyx_XGOTREF(__pyx_t_10);
      __pyx_t_1 = __pyx_lineno; __pyx_t_3 = __pyx_clineno; __pyx_t_4 = __pyx_filename;
      {
        __pyx_t_11 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_subintarray)); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(17, 2044, __pyx_L7_error)
      }
      if (PY_MAJOR_VERSION >= 3) {
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
      }
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_XGIVEREF(__pyx_t_7);
      __Pyx_ErrRestore(__pyx_t_5, __pyx_t_6, __pyx_t_7);
      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      __pyx_lineno = __pyx_t_1; __pyx_clineno = __pyx_t_3; __pyx_filename = __pyx_t_4;
      goto __pyx_L1_error;
      __pyx_L7_error:;
      if (PY_MAJOR_VERSION >= 3) {
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
      }
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      goto __pyx_L1_error;
    }
    __pyx_L5:;
  }

  /* "SLEPc/EPS.pyx":2045
 *         finally:
 *             CHKERR( PetscFree(subintarray) )
 *         return subint             # <<<<<<<<<<<<<<
 * 
 *     def getKrylovSchurInertias(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_subint);
  __pyx_r = __pyx_v_subint;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2026
 *         CHKERR( EPSKrylovSchurSetSubintervals(self.eps, subintarray) )
 * 
 *     def getKrylovSchurSubintervals(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the points that delimit the subintervals used
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getKrylovSchurSubintervals", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_subint);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2047
 *         return subint
 * 
 *     def getKrylovSchurInertias(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of the shifts and their corresponding inertias
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_195getKrylovSchurInertias(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_194getKrylovSchurInertias[] = "EPS.getKrylovSchurInertias(self)\n\n        Gets the values of the shifts and their corresponding inertias\n        in case of doing spectrum slicing for a computational interval.\n\n        Returns\n        -------\n        shifts: list of float\n             The values of the shifts used internally in the solver.\n        inertias: list of int\n             The values of the inertia in each shift.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_195getKrylovSchurInertias(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getKrylovSchurInertias (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getKrylovSchurInertias", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getKrylovSchurInertias", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_194getKrylovSchurInertias(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_194getKrylovSchurInertias(struct PySlepcEPSObject *__pyx_v_self) {
  PetscReal *__pyx_v_shiftsarray;
  PetscInt *__pyx_v_inertiasarray;
  PetscInt __pyx_v_n;
  PyObject *__pyx_v_shifts = 0;
  PyObject *__pyx_v_inertias = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  char const *__pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  PyObject *__pyx_t_10 = NULL;
  int __pyx_t_11;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getKrylovSchurInertias", 0);

  /* "SLEPc/EPS.pyx":2059
 *              The values of the inertia in each shift.
 *         """
 *         cdef PetscReal *shiftsarray = NULL             # <<<<<<<<<<<<<<
 *         cdef PetscInt *inertiasarray = NULL
 *         cdef PetscInt n = 0
 */
  __pyx_v_shiftsarray = NULL;

  /* "SLEPc/EPS.pyx":2060
 *         """
 *         cdef PetscReal *shiftsarray = NULL
 *         cdef PetscInt *inertiasarray = NULL             # <<<<<<<<<<<<<<
 *         cdef PetscInt n = 0
 *         CHKERR(EPSKrylovSchurGetInertias(self.eps, &n, &shiftsarray, &inertiasarray))
 */
  __pyx_v_inertiasarray = NULL;

  /* "SLEPc/EPS.pyx":2061
 *         cdef PetscReal *shiftsarray = NULL
 *         cdef PetscInt *inertiasarray = NULL
 *         cdef PetscInt n = 0             # <<<<<<<<<<<<<<
 *         CHKERR(EPSKrylovSchurGetInertias(self.eps, &n, &shiftsarray, &inertiasarray))
 *         cdef object shifts = None
 */
  __pyx_v_n = 0;

  /* "SLEPc/EPS.pyx":2062
 *         cdef PetscInt *inertiasarray = NULL
 *         cdef PetscInt n = 0
 *         CHKERR(EPSKrylovSchurGetInertias(self.eps, &n, &shiftsarray, &inertiasarray))             # <<<<<<<<<<<<<<
 *         cdef object shifts = None
 *         cdef object inertias = None
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurGetInertias(__pyx_v_self->eps, (&__pyx_v_n), (&__pyx_v_shiftsarray), (&__pyx_v_inertiasarray))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2062, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2063
 *         cdef PetscInt n = 0
 *         CHKERR(EPSKrylovSchurGetInertias(self.eps, &n, &shiftsarray, &inertiasarray))
 *         cdef object shifts = None             # <<<<<<<<<<<<<<
 *         cdef object inertias = None
 *         try:
 */
  __Pyx_INCREF(Py_None);
  __pyx_v_shifts = Py_None;

  /* "SLEPc/EPS.pyx":2064
 *         CHKERR(EPSKrylovSchurGetInertias(self.eps, &n, &shiftsarray, &inertiasarray))
 *         cdef object shifts = None
 *         cdef object inertias = None             # <<<<<<<<<<<<<<
 *         try:
 *             shifts = array_r(n, shiftsarray)
 */
  __Pyx_INCREF(Py_None);
  __pyx_v_inertias = Py_None;

  /* "SLEPc/EPS.pyx":2065
 *         cdef object shifts = None
 *         cdef object inertias = None
 *         try:             # <<<<<<<<<<<<<<
 *             shifts = array_r(n, shiftsarray)
 *             inertias = array_i(n, inertiasarray)
 */
  /*try:*/ {

    /* "SLEPc/EPS.pyx":2066
 *         cdef object inertias = None
 *         try:
 *             shifts = array_r(n, shiftsarray)             # <<<<<<<<<<<<<<
 *             inertias = array_i(n, inertiasarray)
 *         finally:
 */
    __pyx_t_2 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_r(__pyx_v_n, __pyx_v_shiftsarray)); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2066, __pyx_L4_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_shifts, __pyx_t_2);
    __pyx_t_2 = 0;

    /* "SLEPc/EPS.pyx":2067
 *         try:
 *             shifts = array_r(n, shiftsarray)
 *             inertias = array_i(n, inertiasarray)             # <<<<<<<<<<<<<<
 *         finally:
 *             CHKERR( PetscFree(shiftsarray) )
 */
    __pyx_t_2 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_i(__pyx_v_n, __pyx_v_inertiasarray)); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2067, __pyx_L4_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_inertias, __pyx_t_2);
    __pyx_t_2 = 0;
  }

  /* "SLEPc/EPS.pyx":2069
 *             inertias = array_i(n, inertiasarray)
 *         finally:
 *             CHKERR( PetscFree(shiftsarray) )             # <<<<<<<<<<<<<<
 *             CHKERR( PetscFree(inertiasarray) )
 *         return (shifts, inertias)
 */
  /*finally:*/ {
    /*normal exit:*/{
      __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_shiftsarray)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2069, __pyx_L1_error)

      /* "SLEPc/EPS.pyx":2070
 *         finally:
 *             CHKERR( PetscFree(shiftsarray) )
 *             CHKERR( PetscFree(inertiasarray) )             # <<<<<<<<<<<<<<
 *         return (shifts, inertias)
 * 
 */
      __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_inertiasarray)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2070, __pyx_L1_error)
      goto __pyx_L5;
    }
    __pyx_L4_error:;
    /*exception exit:*/{
      __Pyx_PyThreadState_declare
      __Pyx_PyThreadState_assign
      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_5);
      __Pyx_XGOTREF(__pyx_t_6);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_8);
      __Pyx_XGOTREF(__pyx_t_9);
      __Pyx_XGOTREF(__pyx_t_10);
      __pyx_t_1 = __pyx_lineno; __pyx_t_3 = __pyx_clineno; __pyx_t_4 = __pyx_filename;
      {

        /* "SLEPc/EPS.pyx":2069
 *             inertias = array_i(n, inertiasarray)
 *         finally:
 *             CHKERR( PetscFree(shiftsarray) )             # <<<<<<<<<<<<<<
 *             CHKERR( PetscFree(inertiasarray) )
 *         return (shifts, inertias)
 */
        __pyx_t_11 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_shiftsarray)); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(17, 2069, __pyx_L7_error)

        /* "SLEPc/EPS.pyx":2070
 *         finally:
 *             CHKERR( PetscFree(shiftsarray) )
 *             CHKERR( PetscFree(inertiasarray) )             # <<<<<<<<<<<<<<
 *         return (shifts, inertias)
 * 
 */
        __pyx_t_11 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_inertiasarray)); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(17, 2070, __pyx_L7_error)
      }
      if (PY_MAJOR_VERSION >= 3) {
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
      }
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_XGIVEREF(__pyx_t_7);
      __Pyx_ErrRestore(__pyx_t_5, __pyx_t_6, __pyx_t_7);
      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      __pyx_lineno = __pyx_t_1; __pyx_clineno = __pyx_t_3; __pyx_filename = __pyx_t_4;
      goto __pyx_L1_error;
      __pyx_L7_error:;
      if (PY_MAJOR_VERSION >= 3) {
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
      }
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      goto __pyx_L1_error;
    }
    __pyx_L5:;
  }

  /* "SLEPc/EPS.pyx":2071
 *             CHKERR( PetscFree(shiftsarray) )
 *             CHKERR( PetscFree(inertiasarray) )
 *         return (shifts, inertias)             # <<<<<<<<<<<<<<
 * 
 *     def getKrylovSchurKSP(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2071, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_v_shifts);
  __Pyx_GIVEREF(__pyx_v_shifts);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shifts);
  __Pyx_INCREF(__pyx_v_inertias);
  __Pyx_GIVEREF(__pyx_v_inertias);
  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_inertias);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2047
 *         return subint
 * 
 *     def getKrylovSchurInertias(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of the shifts and their corresponding inertias
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getKrylovSchurInertias", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_shifts);
  __Pyx_XDECREF(__pyx_v_inertias);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2073
 *         return (shifts, inertias)
 * 
 *     def getKrylovSchurKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the linear solver object associated with the internal `EPS`
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_197getKrylovSchurKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_196getKrylovSchurKSP[] = "EPS.getKrylovSchurKSP(self)\n\n        Retrieve the linear solver object associated with the internal `EPS`\n        object in case of doing spectrum slicing for a computational interval.\n\n        Returns\n        -------\n        ksp: `KSP`\n             The linear solver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_197getKrylovSchurKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getKrylovSchurKSP (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getKrylovSchurKSP", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getKrylovSchurKSP", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_196getKrylovSchurKSP(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_196getKrylovSchurKSP(struct PySlepcEPSObject *__pyx_v_self) {
  struct PyPetscKSPObject *__pyx_v_ksp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getKrylovSchurKSP", 0);

  /* "SLEPc/EPS.pyx":2083
 *              The linear solver object.
 *         """
 *         cdef KSP ksp = KSP()             # <<<<<<<<<<<<<<
 *         CHKERR( EPSKrylovSchurGetKSP(self.eps, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_KSP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2083, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ksp = ((struct PyPetscKSPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":2084
 *         """
 *         cdef KSP ksp = KSP()
 *         CHKERR( EPSKrylovSchurGetKSP(self.eps, &ksp.ksp) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(ksp.obj)
 *         return ksp
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSKrylovSchurGetKSP(__pyx_v_self->eps, (&__pyx_v_ksp->ksp))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2084, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2085
 *         cdef KSP ksp = KSP()
 *         CHKERR( EPSKrylovSchurGetKSP(self.eps, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)             # <<<<<<<<<<<<<<
 *         return ksp
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ksp->__pyx_base.obj));

  /* "SLEPc/EPS.pyx":2086
 *         CHKERR( EPSKrylovSchurGetKSP(self.eps, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 *         return ksp             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ksp));
  __pyx_r = ((PyObject *)__pyx_v_ksp);
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2073
 *         return (shifts, inertias)
 * 
 *     def getKrylovSchurKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the linear solver object associated with the internal `EPS`
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getKrylovSchurKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ksp);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2090
 *     #
 * 
 *     def setGDKrylovStart(self, krylovstart=True):             # <<<<<<<<<<<<<<
 *         """
 *         Activates or deactivates starting the search subspace
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_199setGDKrylovStart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_198setGDKrylovStart[] = "EPS.setGDKrylovStart(self, krylovstart=True)\n\n        Activates or deactivates starting the search subspace\n        with a Krylov basis.\n\n        Parameters\n        ----------\n        krylovstart: bool\n              True if starting the search subspace with a Krylov basis.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_199setGDKrylovStart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_krylovstart = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setGDKrylovStart (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_krylovstart,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_krylovstart);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setGDKrylovStart") < 0)) __PYX_ERR(17, 2090, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_krylovstart = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setGDKrylovStart", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2090, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setGDKrylovStart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_198setGDKrylovStart(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_krylovstart);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_198setGDKrylovStart(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_krylovstart) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setGDKrylovStart", 0);

  /* "SLEPc/EPS.pyx":2100
 *               True if starting the search subspace with a Krylov basis.
 *         """
 *         cdef PetscBool val = asBool(krylovstart)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGDSetKrylovStart(self.eps, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_krylovstart); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 2100, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2101
 *         """
 *         cdef PetscBool val = asBool(krylovstart)
 *         CHKERR( EPSGDSetKrylovStart(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getGDKrylovStart(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGDSetKrylovStart(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2101, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2090
 *     #
 * 
 *     def setGDKrylovStart(self, krylovstart=True):             # <<<<<<<<<<<<<<
 *         """
 *         Activates or deactivates starting the search subspace
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setGDKrylovStart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2103
 *         CHKERR( EPSGDSetKrylovStart(self.eps, val) )
 * 
 *     def getGDKrylovStart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets a flag indicating if the search subspace is started with a
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_201getGDKrylovStart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_200getGDKrylovStart[] = "EPS.getGDKrylovStart(self)\n\n        Gets a flag indicating if the search subspace is started with a\n        Krylov basis.\n\n        Returns\n        -------\n        krylovstart: bool\n              True if starting the search subspace with a Krylov basis.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_201getGDKrylovStart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getGDKrylovStart (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getGDKrylovStart", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getGDKrylovStart", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_200getGDKrylovStart(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_200getGDKrylovStart(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getGDKrylovStart", 0);

  /* "SLEPc/EPS.pyx":2113
 *               True if starting the search subspace with a Krylov basis.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGDGetKrylovStart(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":2114
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSGDGetKrylovStart(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGDGetKrylovStart(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2114, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2115
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSGDGetKrylovStart(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setGDBlockSize(self, bs):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2115, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2103
 *         CHKERR( EPSGDSetKrylovStart(self.eps, val) )
 * 
 *     def getGDKrylovStart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets a flag indicating if the search subspace is started with a
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getGDKrylovStart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2117
 *         return toBool(tval)
 * 
 *     def setGDBlockSize(self, bs):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of vectors to be added to the searching space
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_203setGDBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_202setGDBlockSize[] = "EPS.setGDBlockSize(self, bs)\n\n        Sets the number of vectors to be added to the searching space\n        in every iteration.\n\n        Parameters\n        ----------\n        bs: int\n            The number of vectors added to the search space in every iteration.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_203setGDBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_bs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setGDBlockSize (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bs,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bs)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setGDBlockSize") < 0)) __PYX_ERR(17, 2117, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_bs = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setGDBlockSize", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2117, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setGDBlockSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_202setGDBlockSize(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_bs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_202setGDBlockSize(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_bs) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setGDBlockSize", 0);

  /* "SLEPc/EPS.pyx":2127
 *             The number of vectors added to the search space in every iteration.
 *         """
 *         cdef PetscInt ival = asInt(bs)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGDSetBlockSize(self.eps, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_bs); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2127, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2128
 *         """
 *         cdef PetscInt ival = asInt(bs)
 *         CHKERR( EPSGDSetBlockSize(self.eps, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getGDBlockSize(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGDSetBlockSize(__pyx_v_self->eps, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2128, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2117
 *         return toBool(tval)
 * 
 *     def setGDBlockSize(self, bs):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of vectors to be added to the searching space
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setGDBlockSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2130
 *         CHKERR( EPSGDSetBlockSize(self.eps, ival) )
 * 
 *     def getGDBlockSize(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of vectors to be added to the searching space
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_205getGDBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_204getGDBlockSize[] = "EPS.getGDBlockSize(self)\n\n        Gets the number of vectors to be added to the searching space\n        in every iteration.\n\n        Returns\n        -------\n        bs: int\n            The number of vectors added to the search space in every iteration.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_205getGDBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getGDBlockSize (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getGDBlockSize", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getGDBlockSize", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_204getGDBlockSize(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_204getGDBlockSize(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getGDBlockSize", 0);

  /* "SLEPc/EPS.pyx":2140
 *             The number of vectors added to the search space in every iteration.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGDGetBlockSize(self.eps, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/EPS.pyx":2141
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( EPSGDGetBlockSize(self.eps, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGDGetBlockSize(__pyx_v_self->eps, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2141, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2142
 *         cdef PetscInt ival = 0
 *         CHKERR( EPSGDGetBlockSize(self.eps, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def setGDRestart(self, minv=None, plusk=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2130
 *         CHKERR( EPSGDSetBlockSize(self.eps, ival) )
 * 
 *     def getGDBlockSize(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of vectors to be added to the searching space
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getGDBlockSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2144
 *         return toInt(ival)
 * 
 *     def setGDRestart(self, minv=None, plusk=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of vectors of the search space after restart and
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_207setGDRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_206setGDRestart[] = "EPS.setGDRestart(self, minv=None, plusk=None)\n\n        Sets the number of vectors of the search space after restart and\n        the number of vectors saved from the previous iteration.\n\n        Parameters\n        ----------\n        minv: int, optional\n              The number of vectors of the search subspace after restart.\n        plusk: int, optional\n              The number of vectors saved from the previous iteration.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_207setGDRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_minv = 0;
  PyObject *__pyx_v_plusk = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setGDRestart (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_minv,&__pyx_n_s_plusk,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_minv);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_plusk);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setGDRestart") < 0)) __PYX_ERR(17, 2144, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_minv = values[0];
    __pyx_v_plusk = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setGDRestart", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2144, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setGDRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_206setGDRestart(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_minv, __pyx_v_plusk);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_206setGDRestart(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_minv, PyObject *__pyx_v_plusk) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setGDRestart", 0);

  /* "SLEPc/EPS.pyx":2156
 *               The number of vectors saved from the previous iteration.
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if minv  is not None: ival1 = asInt(minv)
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2157
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if minv  is not None: ival1 = asInt(minv)
 *         if plusk is not None: ival2 = asInt(plusk)
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2158
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if minv  is not None: ival1 = asInt(minv)             # <<<<<<<<<<<<<<
 *         if plusk is not None: ival2 = asInt(plusk)
 *         CHKERR( EPSGDSetRestart(self.eps, ival1, ival2) )
 */
  __pyx_t_1 = (__pyx_v_minv != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_minv); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2158, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":2159
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if minv  is not None: ival1 = asInt(minv)
 *         if plusk is not None: ival2 = asInt(plusk)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGDSetRestart(self.eps, ival1, ival2) )
 * 
 */
  __pyx_t_2 = (__pyx_v_plusk != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_plusk); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2159, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":2160
 *         if minv  is not None: ival1 = asInt(minv)
 *         if plusk is not None: ival2 = asInt(plusk)
 *         CHKERR( EPSGDSetRestart(self.eps, ival1, ival2) )             # <<<<<<<<<<<<<<
 * 
 *     def getGDRestart(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGDSetRestart(__pyx_v_self->eps, __pyx_v_ival1, __pyx_v_ival2)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(17, 2160, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2144
 *         return toInt(ival)
 * 
 *     def setGDRestart(self, minv=None, plusk=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of vectors of the search space after restart and
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setGDRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2162
 *         CHKERR( EPSGDSetRestart(self.eps, ival1, ival2) )
 * 
 *     def getGDRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of vectors of the search space after restart and
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_209getGDRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_208getGDRestart[] = "EPS.getGDRestart(self)\n\n        Gets the number of vectors of the search space after restart and\n        the number of vectors saved from the previous iteration.\n\n        Returns\n        -------\n        minv: int\n              The number of vectors of the search subspace after restart.\n        plusk: int\n              The number of vectors saved from the previous iteration.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_209getGDRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getGDRestart (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getGDRestart", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getGDRestart", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_208getGDRestart(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_208getGDRestart(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getGDRestart", 0);

  /* "SLEPc/EPS.pyx":2174
 *               The number of vectors saved from the previous iteration.
 *         """
 *         cdef PetscInt ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         CHKERR( EPSGDGetRestart(self.eps, &ival1, &ival2) )
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/EPS.pyx":2175
 *         """
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGDGetRestart(self.eps, &ival1, &ival2) )
 *         return (toInt(ival1), toInt(ival2))
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/EPS.pyx":2176
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0
 *         CHKERR( EPSGDGetRestart(self.eps, &ival1, &ival2) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGDGetRestart(__pyx_v_self->eps, (&__pyx_v_ival1), (&__pyx_v_ival2))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2176, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2177
 *         cdef PetscInt ival2 = 0
 *         CHKERR( EPSGDGetRestart(self.eps, &ival1, &ival2) )
 *         return (toInt(ival1), toInt(ival2))             # <<<<<<<<<<<<<<
 * 
 *     def setGDInitialSize(self, initialsize):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2177, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 2177, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 2177, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2162
 *         CHKERR( EPSGDSetRestart(self.eps, ival1, ival2) )
 * 
 *     def getGDRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of vectors of the search space after restart and
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getGDRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2179
 *         return (toInt(ival1), toInt(ival2))
 * 
 *     def setGDInitialSize(self, initialsize):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the initial size of the searching space.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_211setGDInitialSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_210setGDInitialSize[] = "EPS.setGDInitialSize(self, initialsize)\n\n        Sets the initial size of the searching space.\n\n        Parameters\n        ----------\n        initialsize: int\n            The number of vectors of the initial searching subspace.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_211setGDInitialSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_initialsize = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setGDInitialSize (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_initialsize,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_initialsize)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setGDInitialSize") < 0)) __PYX_ERR(17, 2179, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_initialsize = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setGDInitialSize", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2179, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setGDInitialSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_210setGDInitialSize(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_initialsize);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_210setGDInitialSize(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_initialsize) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setGDInitialSize", 0);

  /* "SLEPc/EPS.pyx":2188
 *             The number of vectors of the initial searching subspace.
 *         """
 *         cdef PetscInt ival = asInt(initialsize)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGDSetInitialSize(self.eps, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_initialsize); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2188, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2189
 *         """
 *         cdef PetscInt ival = asInt(initialsize)
 *         CHKERR( EPSGDSetInitialSize(self.eps, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getGDInitialSize(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGDSetInitialSize(__pyx_v_self->eps, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2189, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2179
 *         return (toInt(ival1), toInt(ival2))
 * 
 *     def setGDInitialSize(self, initialsize):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the initial size of the searching space.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setGDInitialSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2191
 *         CHKERR( EPSGDSetInitialSize(self.eps, ival) )
 * 
 *     def getGDInitialSize(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the initial size of the searching space.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_213getGDInitialSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_212getGDInitialSize[] = "EPS.getGDInitialSize(self)\n\n        Gets the initial size of the searching space.\n\n        Returns\n        -------\n        initialsize: int\n            The number of vectors of the initial searching subspace.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_213getGDInitialSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getGDInitialSize (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getGDInitialSize", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getGDInitialSize", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_212getGDInitialSize(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_212getGDInitialSize(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getGDInitialSize", 0);

  /* "SLEPc/EPS.pyx":2200
 *             The number of vectors of the initial searching subspace.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGDGetInitialSize(self.eps, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/EPS.pyx":2201
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( EPSGDGetInitialSize(self.eps, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGDGetInitialSize(__pyx_v_self->eps, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2201, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2202
 *         cdef PetscInt ival = 0
 *         CHKERR( EPSGDGetInitialSize(self.eps, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def setGDBOrth(self, borth):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2191
 *         CHKERR( EPSGDSetInitialSize(self.eps, ival) )
 * 
 *     def getGDInitialSize(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the initial size of the searching space.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getGDInitialSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2204
 *         return toInt(ival)
 * 
 *     def setGDBOrth(self, borth):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the orthogonalization that will be used in the search
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_215setGDBOrth(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_214setGDBOrth[] = "EPS.setGDBOrth(self, borth)\n\n        Selects the orthogonalization that will be used in the search\n        subspace in case of generalized Hermitian problems.\n\n        Parameters\n        ----------\n        borth: bool\n              Whether to B-orthogonalize the search subspace.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_215setGDBOrth(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_borth = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setGDBOrth (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_borth,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_borth)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setGDBOrth") < 0)) __PYX_ERR(17, 2204, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_borth = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setGDBOrth", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2204, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setGDBOrth", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_214setGDBOrth(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_borth);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_214setGDBOrth(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_borth) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setGDBOrth", 0);

  /* "SLEPc/EPS.pyx":2214
 *               Whether to B-orthogonalize the search subspace.
 *         """
 *         cdef PetscBool tval = asBool(borth)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGDSetBOrth(self.eps, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_borth); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 2214, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2215
 *         """
 *         cdef PetscBool tval = asBool(borth)
 *         CHKERR( EPSGDSetBOrth(self.eps, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getGDBOrth(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGDSetBOrth(__pyx_v_self->eps, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2215, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2204
 *         return toInt(ival)
 * 
 *     def setGDBOrth(self, borth):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the orthogonalization that will be used in the search
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setGDBOrth", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2217
 *         CHKERR( EPSGDSetBOrth(self.eps, tval) )
 * 
 *     def getGDBOrth(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the orthogonalization used in the search subspace in
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_217getGDBOrth(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_216getGDBOrth[] = "EPS.getGDBOrth(self)\n\n        Returns the orthogonalization used in the search subspace in\n        case of generalized Hermitian problems.\n\n        Returns\n        -------\n        borth: bool\n              Whether to B-orthogonalize the search subspace.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_217getGDBOrth(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getGDBOrth (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getGDBOrth", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getGDBOrth", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_216getGDBOrth(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_216getGDBOrth(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getGDBOrth", 0);

  /* "SLEPc/EPS.pyx":2227
 *               Whether to B-orthogonalize the search subspace.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGDGetBOrth(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":2228
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSGDGetBOrth(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGDGetBOrth(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2228, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2229
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSGDGetBOrth(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setGDDoubleExpansion(self, doubleexp):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2229, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2217
 *         CHKERR( EPSGDSetBOrth(self.eps, tval) )
 * 
 *     def getGDBOrth(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the orthogonalization used in the search subspace in
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getGDBOrth", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2231
 *         return toBool(tval)
 * 
 *     def setGDDoubleExpansion(self, doubleexp):             # <<<<<<<<<<<<<<
 *         """
 *         Activate a variant where the search subspace is expanded  with
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_219setGDDoubleExpansion(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_218setGDDoubleExpansion[] = "EPS.setGDDoubleExpansion(self, doubleexp)\n\n        Activate a variant where the search subspace is expanded  with\n        K*[A*x B*x] (double expansion) instead of the classic K*r, where\n        K is the preconditioner, x the selected approximate eigenvector\n        and r its associated residual vector.\n\n        Parameters\n        ----------\n        doubleexp: bool\n              True if using double expansion.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_219setGDDoubleExpansion(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_doubleexp = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setGDDoubleExpansion (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_doubleexp,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_doubleexp)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setGDDoubleExpansion") < 0)) __PYX_ERR(17, 2231, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_doubleexp = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setGDDoubleExpansion", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2231, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setGDDoubleExpansion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_218setGDDoubleExpansion(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_doubleexp);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_218setGDDoubleExpansion(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_doubleexp) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setGDDoubleExpansion", 0);

  /* "SLEPc/EPS.pyx":2243
 *               True if using double expansion.
 *         """
 *         cdef PetscBool val = asBool(doubleexp)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGDSetDoubleExpansion(self.eps, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_doubleexp); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 2243, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2244
 *         """
 *         cdef PetscBool val = asBool(doubleexp)
 *         CHKERR( EPSGDSetDoubleExpansion(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getGDDoubleExpansion(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGDSetDoubleExpansion(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2244, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2231
 *         return toBool(tval)
 * 
 *     def setGDDoubleExpansion(self, doubleexp):             # <<<<<<<<<<<<<<
 *         """
 *         Activate a variant where the search subspace is expanded  with
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setGDDoubleExpansion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2246
 *         CHKERR( EPSGDSetDoubleExpansion(self.eps, val) )
 * 
 *     def getGDDoubleExpansion(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets a flag indicating whether the double expansion variant
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_221getGDDoubleExpansion(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_220getGDDoubleExpansion[] = "EPS.getGDDoubleExpansion(self)\n\n        Gets a flag indicating whether the double expansion variant\n        has been activated or not.\n\n        Returns\n        -------\n        doubleexp: bool\n              True if using double expansion.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_221getGDDoubleExpansion(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getGDDoubleExpansion (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getGDDoubleExpansion", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getGDDoubleExpansion", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_220getGDDoubleExpansion(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_220getGDDoubleExpansion(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getGDDoubleExpansion", 0);

  /* "SLEPc/EPS.pyx":2256
 *               True if using double expansion.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSGDGetDoubleExpansion(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":2257
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSGDGetDoubleExpansion(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSGDGetDoubleExpansion(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2257, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2258
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSGDGetDoubleExpansion(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2258, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2246
 *         CHKERR( EPSGDSetDoubleExpansion(self.eps, val) )
 * 
 *     def getGDDoubleExpansion(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets a flag indicating whether the double expansion variant
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getGDDoubleExpansion", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2262
 *     #
 * 
 *     def setJDKrylovStart(self, krylovstart=True):             # <<<<<<<<<<<<<<
 *         """
 *         Activates or deactivates starting the search subspace
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_223setJDKrylovStart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_222setJDKrylovStart[] = "EPS.setJDKrylovStart(self, krylovstart=True)\n\n        Activates or deactivates starting the search subspace\n        with a Krylov basis.\n\n        Parameters\n        ----------\n        krylovstart: bool\n              True if starting the search subspace with a Krylov basis.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_223setJDKrylovStart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_krylovstart = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setJDKrylovStart (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_krylovstart,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_krylovstart);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setJDKrylovStart") < 0)) __PYX_ERR(17, 2262, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_krylovstart = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setJDKrylovStart", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2262, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setJDKrylovStart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_222setJDKrylovStart(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_krylovstart);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_222setJDKrylovStart(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_krylovstart) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setJDKrylovStart", 0);

  /* "SLEPc/EPS.pyx":2272
 *               True if starting the search subspace with a Krylov basis.
 *         """
 *         cdef PetscBool val = asBool(krylovstart)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSJDSetKrylovStart(self.eps, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_krylovstart); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 2272, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2273
 *         """
 *         cdef PetscBool val = asBool(krylovstart)
 *         CHKERR( EPSJDSetKrylovStart(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getJDKrylovStart(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSJDSetKrylovStart(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2273, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2262
 *     #
 * 
 *     def setJDKrylovStart(self, krylovstart=True):             # <<<<<<<<<<<<<<
 *         """
 *         Activates or deactivates starting the search subspace
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setJDKrylovStart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2275
 *         CHKERR( EPSJDSetKrylovStart(self.eps, val) )
 * 
 *     def getJDKrylovStart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets a flag indicating if the search subspace is started with a
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_225getJDKrylovStart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_224getJDKrylovStart[] = "EPS.getJDKrylovStart(self)\n\n        Gets a flag indicating if the search subspace is started with a\n        Krylov basis.\n\n        Returns\n        -------\n        krylovstart: bool\n              True if starting the search subspace with a Krylov basis.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_225getJDKrylovStart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getJDKrylovStart (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getJDKrylovStart", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getJDKrylovStart", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_224getJDKrylovStart(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_224getJDKrylovStart(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getJDKrylovStart", 0);

  /* "SLEPc/EPS.pyx":2285
 *               True if starting the search subspace with a Krylov basis.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSJDGetKrylovStart(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":2286
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSJDGetKrylovStart(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSJDGetKrylovStart(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2286, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2287
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSJDGetKrylovStart(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setJDBlockSize(self, bs):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2287, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2275
 *         CHKERR( EPSJDSetKrylovStart(self.eps, val) )
 * 
 *     def getJDKrylovStart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets a flag indicating if the search subspace is started with a
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getJDKrylovStart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2289
 *         return toBool(tval)
 * 
 *     def setJDBlockSize(self, bs):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of vectors to be added to the searching space
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_227setJDBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_226setJDBlockSize[] = "EPS.setJDBlockSize(self, bs)\n\n        Sets the number of vectors to be added to the searching space\n        in every iteration.\n\n        Parameters\n        ----------\n        bs: int\n            The number of vectors added to the search space in every iteration.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_227setJDBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_bs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setJDBlockSize (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bs,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bs)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setJDBlockSize") < 0)) __PYX_ERR(17, 2289, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_bs = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setJDBlockSize", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2289, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setJDBlockSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_226setJDBlockSize(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_bs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_226setJDBlockSize(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_bs) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setJDBlockSize", 0);

  /* "SLEPc/EPS.pyx":2299
 *             The number of vectors added to the search space in every iteration.
 *         """
 *         cdef PetscInt ival = asInt(bs)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSJDSetBlockSize(self.eps, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_bs); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2299, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2300
 *         """
 *         cdef PetscInt ival = asInt(bs)
 *         CHKERR( EPSJDSetBlockSize(self.eps, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getJDBlockSize(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSJDSetBlockSize(__pyx_v_self->eps, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2300, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2289
 *         return toBool(tval)
 * 
 *     def setJDBlockSize(self, bs):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of vectors to be added to the searching space
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setJDBlockSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2302
 *         CHKERR( EPSJDSetBlockSize(self.eps, ival) )
 * 
 *     def getJDBlockSize(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of vectors to be added to the searching space
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_229getJDBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_228getJDBlockSize[] = "EPS.getJDBlockSize(self)\n\n        Gets the number of vectors to be added to the searching space\n        in every iteration.\n\n        Returns\n        -------\n        bs: int\n            The number of vectors added to the search space in every iteration.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_229getJDBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getJDBlockSize (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getJDBlockSize", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getJDBlockSize", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_228getJDBlockSize(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_228getJDBlockSize(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getJDBlockSize", 0);

  /* "SLEPc/EPS.pyx":2312
 *             The number of vectors added to the search space in every iteration.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSJDGetBlockSize(self.eps, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/EPS.pyx":2313
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( EPSJDGetBlockSize(self.eps, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSJDGetBlockSize(__pyx_v_self->eps, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2313, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2314
 *         cdef PetscInt ival = 0
 *         CHKERR( EPSJDGetBlockSize(self.eps, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def setJDRestart(self, minv=None, plusk=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2314, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2302
 *         CHKERR( EPSJDSetBlockSize(self.eps, ival) )
 * 
 *     def getJDBlockSize(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of vectors to be added to the searching space
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getJDBlockSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2316
 *         return toInt(ival)
 * 
 *     def setJDRestart(self, minv=None, plusk=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of vectors of the search space after restart and
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_231setJDRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_230setJDRestart[] = "EPS.setJDRestart(self, minv=None, plusk=None)\n\n        Sets the number of vectors of the search space after restart and\n        the number of vectors saved from the previous iteration.\n\n        Parameters\n        ----------\n        minv: int, optional\n              The number of vectors of the search subspace after restart.\n        plusk: int, optional\n              The number of vectors saved from the previous iteration.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_231setJDRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_minv = 0;
  PyObject *__pyx_v_plusk = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setJDRestart (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_minv,&__pyx_n_s_plusk,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_minv);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_plusk);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setJDRestart") < 0)) __PYX_ERR(17, 2316, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_minv = values[0];
    __pyx_v_plusk = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setJDRestart", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2316, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setJDRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_230setJDRestart(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_minv, __pyx_v_plusk);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_230setJDRestart(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_minv, PyObject *__pyx_v_plusk) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setJDRestart", 0);

  /* "SLEPc/EPS.pyx":2328
 *               The number of vectors saved from the previous iteration.
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if minv  is not None: ival1 = asInt(minv)
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2329
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if minv  is not None: ival1 = asInt(minv)
 *         if plusk is not None: ival2 = asInt(plusk)
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2330
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if minv  is not None: ival1 = asInt(minv)             # <<<<<<<<<<<<<<
 *         if plusk is not None: ival2 = asInt(plusk)
 *         CHKERR( EPSJDSetRestart(self.eps, ival1, ival2) )
 */
  __pyx_t_1 = (__pyx_v_minv != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_minv); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2330, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":2331
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if minv  is not None: ival1 = asInt(minv)
 *         if plusk is not None: ival2 = asInt(plusk)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSJDSetRestart(self.eps, ival1, ival2) )
 * 
 */
  __pyx_t_2 = (__pyx_v_plusk != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_plusk); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2331, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":2332
 *         if minv  is not None: ival1 = asInt(minv)
 *         if plusk is not None: ival2 = asInt(plusk)
 *         CHKERR( EPSJDSetRestart(self.eps, ival1, ival2) )             # <<<<<<<<<<<<<<
 * 
 *     def getJDRestart(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSJDSetRestart(__pyx_v_self->eps, __pyx_v_ival1, __pyx_v_ival2)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(17, 2332, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2316
 *         return toInt(ival)
 * 
 *     def setJDRestart(self, minv=None, plusk=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of vectors of the search space after restart and
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setJDRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2334
 *         CHKERR( EPSJDSetRestart(self.eps, ival1, ival2) )
 * 
 *     def getJDRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of vectors of the search space after restart and
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_233getJDRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_232getJDRestart[] = "EPS.getJDRestart(self)\n\n        Gets the number of vectors of the search space after restart and\n        the number of vectors saved from the previous iteration.\n\n        Returns\n        -------\n        minv: int\n              The number of vectors of the search subspace after restart.\n        plusk: int\n              The number of vectors saved from the previous iteration.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_233getJDRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getJDRestart (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getJDRestart", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getJDRestart", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_232getJDRestart(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_232getJDRestart(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getJDRestart", 0);

  /* "SLEPc/EPS.pyx":2346
 *               The number of vectors saved from the previous iteration.
 *         """
 *         cdef PetscInt ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         CHKERR( EPSJDGetRestart(self.eps, &ival1, &ival2) )
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/EPS.pyx":2347
 *         """
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSJDGetRestart(self.eps, &ival1, &ival2) )
 *         return (toInt(ival1), toInt(ival2))
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/EPS.pyx":2348
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0
 *         CHKERR( EPSJDGetRestart(self.eps, &ival1, &ival2) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSJDGetRestart(__pyx_v_self->eps, (&__pyx_v_ival1), (&__pyx_v_ival2))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2348, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2349
 *         cdef PetscInt ival2 = 0
 *         CHKERR( EPSJDGetRestart(self.eps, &ival1, &ival2) )
 *         return (toInt(ival1), toInt(ival2))             # <<<<<<<<<<<<<<
 * 
 *     def setJDInitialSize(self, initialsize):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 2349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 2349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2334
 *         CHKERR( EPSJDSetRestart(self.eps, ival1, ival2) )
 * 
 *     def getJDRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of vectors of the search space after restart and
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getJDRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2351
 *         return (toInt(ival1), toInt(ival2))
 * 
 *     def setJDInitialSize(self, initialsize):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the initial size of the searching space.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_235setJDInitialSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_234setJDInitialSize[] = "EPS.setJDInitialSize(self, initialsize)\n\n        Sets the initial size of the searching space.\n\n        Parameters\n        ----------\n        initialsize: int\n            The number of vectors of the initial searching subspace.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_235setJDInitialSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_initialsize = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setJDInitialSize (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_initialsize,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_initialsize)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setJDInitialSize") < 0)) __PYX_ERR(17, 2351, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_initialsize = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setJDInitialSize", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2351, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setJDInitialSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_234setJDInitialSize(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_initialsize);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_234setJDInitialSize(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_initialsize) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setJDInitialSize", 0);

  /* "SLEPc/EPS.pyx":2360
 *             The number of vectors of the initial searching subspace.
 *         """
 *         cdef PetscInt ival = asInt(initialsize)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSJDSetInitialSize(self.eps, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_initialsize); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2360, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2361
 *         """
 *         cdef PetscInt ival = asInt(initialsize)
 *         CHKERR( EPSJDSetInitialSize(self.eps, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getJDInitialSize(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSJDSetInitialSize(__pyx_v_self->eps, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2361, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2351
 *         return (toInt(ival1), toInt(ival2))
 * 
 *     def setJDInitialSize(self, initialsize):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the initial size of the searching space.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setJDInitialSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2363
 *         CHKERR( EPSJDSetInitialSize(self.eps, ival) )
 * 
 *     def getJDInitialSize(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the initial size of the searching space.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_237getJDInitialSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_236getJDInitialSize[] = "EPS.getJDInitialSize(self)\n\n        Gets the initial size of the searching space.\n\n        Returns\n        -------\n        initialsize: int\n            The number of vectors of the initial searching subspace.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_237getJDInitialSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getJDInitialSize (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getJDInitialSize", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getJDInitialSize", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_236getJDInitialSize(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_236getJDInitialSize(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getJDInitialSize", 0);

  /* "SLEPc/EPS.pyx":2372
 *             The number of vectors of the initial searching subspace.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSJDGetInitialSize(self.eps, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/EPS.pyx":2373
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( EPSJDGetInitialSize(self.eps, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSJDGetInitialSize(__pyx_v_self->eps, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2373, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2374
 *         cdef PetscInt ival = 0
 *         CHKERR( EPSJDGetInitialSize(self.eps, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def setJDFix(self, fix):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2374, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2363
 *         CHKERR( EPSJDSetInitialSize(self.eps, ival) )
 * 
 *     def getJDInitialSize(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the initial size of the searching space.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getJDInitialSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2376
 *         return toInt(ival)
 * 
 *     def setJDFix(self, fix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the threshold for changing the target in the correction equation.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_239setJDFix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_238setJDFix[] = "EPS.setJDFix(self, fix)\n\n        Sets the threshold for changing the target in the correction equation.\n\n        Parameters\n        ----------\n        fix: float\n             The threshold for changing the target.\n\n        Notes\n        -----\n        The target in the correction equation is fixed at the first iterations.\n        When the norm of the residual vector is lower than the fix value,\n        the target is set to the corresponding eigenvalue.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_239setJDFix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_fix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setJDFix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setJDFix") < 0)) __PYX_ERR(17, 2376, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_fix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setJDFix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2376, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setJDFix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_238setJDFix(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_fix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_238setJDFix(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_fix) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setJDFix", 0);

  /* "SLEPc/EPS.pyx":2391
 *         the target is set to the corresponding eigenvalue.
 *         """
 *         cdef PetscReal val = asReal(fix)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSJDSetFix(self.eps, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_fix); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(17, 2391, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2392
 *         """
 *         cdef PetscReal val = asReal(fix)
 *         CHKERR( EPSJDSetFix(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getJDFix(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSJDSetFix(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2392, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2376
 *         return toInt(ival)
 * 
 *     def setJDFix(self, fix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the threshold for changing the target in the correction equation.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setJDFix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2394
 *         CHKERR( EPSJDSetFix(self.eps, val) )
 * 
 *     def getJDFix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the threshold for changing the target in the correction equation.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_241getJDFix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_240getJDFix[] = "EPS.getJDFix(self)\n\n        Gets the threshold for changing the target in the correction equation.\n\n        Returns\n        -------\n        fix: float\n             The threshold for changing the target.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_241getJDFix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getJDFix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getJDFix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getJDFix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_240getJDFix(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_240getJDFix(struct PySlepcEPSObject *__pyx_v_self) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getJDFix", 0);

  /* "SLEPc/EPS.pyx":2403
 *              The threshold for changing the target.
 *         """
 *         cdef PetscReal val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSJDGetFix(self.eps, &val) )
 *         return toReal(val)
 */
  __pyx_v_val = 0.0;

  /* "SLEPc/EPS.pyx":2404
 *         """
 *         cdef PetscReal val = 0
 *         CHKERR( EPSJDGetFix(self.eps, &val) )             # <<<<<<<<<<<<<<
 *         return toReal(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSJDGetFix(__pyx_v_self->eps, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2404, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2405
 *         cdef PetscReal val = 0
 *         CHKERR( EPSJDGetFix(self.eps, &val) )
 *         return toReal(val)             # <<<<<<<<<<<<<<
 * 
 *     def setJDConstCorrectionTol(self, constant):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2405, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2394
 *         CHKERR( EPSJDSetFix(self.eps, val) )
 * 
 *     def getJDFix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the threshold for changing the target in the correction equation.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getJDFix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2407
 *         return toReal(val)
 * 
 *     def setJDConstCorrectionTol(self, constant):             # <<<<<<<<<<<<<<
 *         """
 *         Deactivates the dynamic stopping criterion that sets the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_243setJDConstCorrectionTol(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_242setJDConstCorrectionTol[] = "EPS.setJDConstCorrectionTol(self, constant)\n\n        Deactivates the dynamic stopping criterion that sets the\n        `KSP` relative tolerance to `0.5**i`, where `i` is the number\n        of `EPS` iterations from the last converged value.\n\n        Parameters\n        ----------\n        constant: bool\n              If False, the `KSP` relative tolerance is set to `0.5**i`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_243setJDConstCorrectionTol(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_constant = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setJDConstCorrectionTol (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constant,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_constant)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setJDConstCorrectionTol") < 0)) __PYX_ERR(17, 2407, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_constant = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setJDConstCorrectionTol", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2407, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setJDConstCorrectionTol", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_242setJDConstCorrectionTol(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_constant);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_242setJDConstCorrectionTol(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_constant) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setJDConstCorrectionTol", 0);

  /* "SLEPc/EPS.pyx":2418
 *               If False, the `KSP` relative tolerance is set to `0.5**i`.
 *         """
 *         cdef PetscBool tval = asBool(constant)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSJDSetConstCorrectionTol(self.eps, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_constant); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 2418, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2419
 *         """
 *         cdef PetscBool tval = asBool(constant)
 *         CHKERR( EPSJDSetConstCorrectionTol(self.eps, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getJDConstCorrectionTol(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSJDSetConstCorrectionTol(__pyx_v_self->eps, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2419, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2407
 *         return toReal(val)
 * 
 *     def setJDConstCorrectionTol(self, constant):             # <<<<<<<<<<<<<<
 *         """
 *         Deactivates the dynamic stopping criterion that sets the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setJDConstCorrectionTol", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2421
 *         CHKERR( EPSJDSetConstCorrectionTol(self.eps, tval) )
 * 
 *     def getJDConstCorrectionTol(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating if the dynamic stopping is being used for
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_245getJDConstCorrectionTol(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_244getJDConstCorrectionTol[] = "EPS.getJDConstCorrectionTol(self)\n\n        Returns the flag indicating if the dynamic stopping is being used for\n        solving the correction equation.\n\n        Returns\n        -------\n        constant: bool\n              Flag indicating if the dynamic stopping criterion is not being used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_245getJDConstCorrectionTol(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getJDConstCorrectionTol (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getJDConstCorrectionTol", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getJDConstCorrectionTol", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_244getJDConstCorrectionTol(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_244getJDConstCorrectionTol(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getJDConstCorrectionTol", 0);

  /* "SLEPc/EPS.pyx":2431
 *               Flag indicating if the dynamic stopping criterion is not being used.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSJDGetConstCorrectionTol(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":2432
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSJDGetConstCorrectionTol(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSJDGetConstCorrectionTol(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2432, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2433
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSJDGetConstCorrectionTol(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setJDBOrth(self, borth):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2433, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2421
 *         CHKERR( EPSJDSetConstCorrectionTol(self.eps, tval) )
 * 
 *     def getJDConstCorrectionTol(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating if the dynamic stopping is being used for
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getJDConstCorrectionTol", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2435
 *         return toBool(tval)
 * 
 *     def setJDBOrth(self, borth):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the orthogonalization that will be used in the search
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_247setJDBOrth(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_246setJDBOrth[] = "EPS.setJDBOrth(self, borth)\n\n        Selects the orthogonalization that will be used in the search\n        subspace in case of generalized Hermitian problems.\n\n        Parameters\n        ----------\n        borth: bool\n              Whether to B-orthogonalize the search subspace.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_247setJDBOrth(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_borth = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setJDBOrth (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_borth,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_borth)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setJDBOrth") < 0)) __PYX_ERR(17, 2435, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_borth = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setJDBOrth", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2435, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setJDBOrth", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_246setJDBOrth(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_borth);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_246setJDBOrth(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_borth) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setJDBOrth", 0);

  /* "SLEPc/EPS.pyx":2445
 *               Whether to B-orthogonalize the search subspace.
 *         """
 *         cdef PetscBool tval = asBool(borth)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSJDSetBOrth(self.eps, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_borth); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 2445, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2446
 *         """
 *         cdef PetscBool tval = asBool(borth)
 *         CHKERR( EPSJDSetBOrth(self.eps, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getJDBOrth(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSJDSetBOrth(__pyx_v_self->eps, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2446, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2435
 *         return toBool(tval)
 * 
 *     def setJDBOrth(self, borth):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the orthogonalization that will be used in the search
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setJDBOrth", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2448
 *         CHKERR( EPSJDSetBOrth(self.eps, tval) )
 * 
 *     def getJDBOrth(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the orthogonalization used in the search subspace in
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_249getJDBOrth(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_248getJDBOrth[] = "EPS.getJDBOrth(self)\n\n        Returns the orthogonalization used in the search subspace in\n        case of generalized Hermitian problems.\n\n        Returns\n        -------\n        borth: bool\n              Whether to B-orthogonalize the search subspace.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_249getJDBOrth(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getJDBOrth (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getJDBOrth", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getJDBOrth", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_248getJDBOrth(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_248getJDBOrth(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getJDBOrth", 0);

  /* "SLEPc/EPS.pyx":2458
 *               Whether to B-orthogonalize the search subspace.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSJDGetBOrth(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":2459
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSJDGetBOrth(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSJDGetBOrth(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2459, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2460
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSJDGetBOrth(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2460, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2448
 *         CHKERR( EPSJDSetBOrth(self.eps, tval) )
 * 
 *     def getJDBOrth(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the orthogonalization used in the search subspace in
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getJDBOrth", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2464
 *     #
 * 
 *     def setRQCGReset(self, nrest):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the reset parameter of the RQCG iteration. Every nrest iterations,
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_251setRQCGReset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_250setRQCGReset[] = "EPS.setRQCGReset(self, nrest)\n\n        Sets the reset parameter of the RQCG iteration. Every nrest iterations,\n        the solver performs a Rayleigh-Ritz projection step.\n\n        Parameters\n        ----------\n        nrest: int\n               The number of iterations between resets.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_251setRQCGReset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nrest = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRQCGReset (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nrest,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nrest)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRQCGReset") < 0)) __PYX_ERR(17, 2464, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_nrest = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRQCGReset", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2464, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setRQCGReset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_250setRQCGReset(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_nrest);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_250setRQCGReset(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_nrest) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRQCGReset", 0);

  /* "SLEPc/EPS.pyx":2474
 *                The number of iterations between resets.
 *         """
 *         cdef PetscInt val = asInt(nrest)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSRQCGSetReset(self.eps, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_nrest); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2474, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2475
 *         """
 *         cdef PetscInt val = asInt(nrest)
 *         CHKERR( EPSRQCGSetReset(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getRQCGReset(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSRQCGSetReset(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2475, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2464
 *     #
 * 
 *     def setRQCGReset(self, nrest):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the reset parameter of the RQCG iteration. Every nrest iterations,
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setRQCGReset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2477
 *         CHKERR( EPSRQCGSetReset(self.eps, val) )
 * 
 *     def getRQCGReset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the reset parameter used in the RQCG method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_253getRQCGReset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_252getRQCGReset[] = "EPS.getRQCGReset(self)\n\n        Gets the reset parameter used in the RQCG method.\n\n        Returns\n        -------\n        nrest: int\n               The number of iterations between resets.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_253getRQCGReset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRQCGReset (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRQCGReset", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRQCGReset", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_252getRQCGReset(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_252getRQCGReset(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRQCGReset", 0);

  /* "SLEPc/EPS.pyx":2486
 *                The number of iterations between resets.
 *         """
 *         cdef PetscInt val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSRQCGGetReset(self.eps, &val) )
 *         return toInt(val)
 */
  __pyx_v_val = 0;

  /* "SLEPc/EPS.pyx":2487
 *         """
 *         cdef PetscInt val = 0
 *         CHKERR( EPSRQCGGetReset(self.eps, &val) )             # <<<<<<<<<<<<<<
 *         return toInt(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSRQCGGetReset(__pyx_v_self->eps, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2487, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2488
 *         cdef PetscInt val = 0
 *         CHKERR( EPSRQCGGetReset(self.eps, &val) )
 *         return toInt(val)             # <<<<<<<<<<<<<<
 * 
 *     def setLOBPCGBlockSize(self, bs):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2488, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2477
 *         CHKERR( EPSRQCGSetReset(self.eps, val) )
 * 
 *     def getRQCGReset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the reset parameter used in the RQCG method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getRQCGReset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2490
 *         return toInt(val)
 * 
 *     def setLOBPCGBlockSize(self, bs):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the block size of the LOBPCG method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_255setLOBPCGBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_254setLOBPCGBlockSize[] = "EPS.setLOBPCGBlockSize(self, bs)\n\n        Sets the block size of the LOBPCG method.\n\n        Parameters\n        ----------\n        bs: int\n            The block size.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_255setLOBPCGBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_bs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setLOBPCGBlockSize (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bs,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bs)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setLOBPCGBlockSize") < 0)) __PYX_ERR(17, 2490, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_bs = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setLOBPCGBlockSize", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2490, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setLOBPCGBlockSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_254setLOBPCGBlockSize(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_bs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_254setLOBPCGBlockSize(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_bs) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setLOBPCGBlockSize", 0);

  /* "SLEPc/EPS.pyx":2499
 *             The block size.
 *         """
 *         cdef PetscInt ival = asInt(bs)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSLOBPCGSetBlockSize(self.eps, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_bs); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2499, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2500
 *         """
 *         cdef PetscInt ival = asInt(bs)
 *         CHKERR( EPSLOBPCGSetBlockSize(self.eps, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getLOBPCGBlockSize(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSLOBPCGSetBlockSize(__pyx_v_self->eps, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2500, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2490
 *         return toInt(val)
 * 
 *     def setLOBPCGBlockSize(self, bs):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the block size of the LOBPCG method.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setLOBPCGBlockSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2502
 *         CHKERR( EPSLOBPCGSetBlockSize(self.eps, ival) )
 * 
 *     def getLOBPCGBlockSize(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the block size used in the LOBPCG method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_257getLOBPCGBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_256getLOBPCGBlockSize[] = "EPS.getLOBPCGBlockSize(self)\n\n        Gets the block size used in the LOBPCG method.\n\n        Returns\n        -------\n        bs: int\n            The block size.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_257getLOBPCGBlockSize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getLOBPCGBlockSize (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getLOBPCGBlockSize", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLOBPCGBlockSize", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_256getLOBPCGBlockSize(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_256getLOBPCGBlockSize(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getLOBPCGBlockSize", 0);

  /* "SLEPc/EPS.pyx":2511
 *             The block size.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSLOBPCGGetBlockSize(self.eps, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/EPS.pyx":2512
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( EPSLOBPCGGetBlockSize(self.eps, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSLOBPCGGetBlockSize(__pyx_v_self->eps, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2512, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2513
 *         cdef PetscInt ival = 0
 *         CHKERR( EPSLOBPCGGetBlockSize(self.eps, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def setLOBPCGRestart(self, restart):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2513, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2502
 *         CHKERR( EPSLOBPCGSetBlockSize(self.eps, ival) )
 * 
 *     def getLOBPCGBlockSize(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the block size used in the LOBPCG method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getLOBPCGBlockSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2515
 *         return toInt(ival)
 * 
 *     def setLOBPCGRestart(self, restart):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the restart parameter for the LOBPCG method. The meaning
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_259setLOBPCGRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_258setLOBPCGRestart[] = "EPS.setLOBPCGRestart(self, restart)\n\n        Sets the restart parameter for the LOBPCG method. The meaning\n        of this parameter is the proportion of vectors within the\n        current block iterate that must have converged in order to force\n        a restart with hard locking.\n\n        Parameters\n        ----------\n        restart: float\n              The percentage of the block of vectors to force a restart.\n\n        Notes\n        -----\n        Allowed values are in the range [0.1,1.0]. The default is 0.9.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_259setLOBPCGRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_restart = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setLOBPCGRestart (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_restart,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_restart)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setLOBPCGRestart") < 0)) __PYX_ERR(17, 2515, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_restart = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setLOBPCGRestart", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2515, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setLOBPCGRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_258setLOBPCGRestart(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_restart);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_258setLOBPCGRestart(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_restart) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setLOBPCGRestart", 0);

  /* "SLEPc/EPS.pyx":2531
 *         Allowed values are in the range [0.1,1.0]. The default is 0.9.
 *         """
 *         cdef PetscReal val = asReal(restart)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSLOBPCGSetRestart(self.eps, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_restart); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(17, 2531, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2532
 *         """
 *         cdef PetscReal val = asReal(restart)
 *         CHKERR( EPSLOBPCGSetRestart(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getLOBPCGRestart(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSLOBPCGSetRestart(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2532, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2515
 *         return toInt(ival)
 * 
 *     def setLOBPCGRestart(self, restart):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the restart parameter for the LOBPCG method. The meaning
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setLOBPCGRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2534
 *         CHKERR( EPSLOBPCGSetRestart(self.eps, val) )
 * 
 *     def getLOBPCGRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the restart parameter used in the LOBPCG method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_261getLOBPCGRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_260getLOBPCGRestart[] = "EPS.getLOBPCGRestart(self)\n\n        Gets the restart parameter used in the LOBPCG method.\n\n        Returns\n        -------\n        restart: float\n              The restart parameter.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_261getLOBPCGRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getLOBPCGRestart (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getLOBPCGRestart", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLOBPCGRestart", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_260getLOBPCGRestart(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_260getLOBPCGRestart(struct PySlepcEPSObject *__pyx_v_self) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getLOBPCGRestart", 0);

  /* "SLEPc/EPS.pyx":2543
 *               The restart parameter.
 *         """
 *         cdef PetscReal val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSLOBPCGGetRestart(self.eps, &val) )
 *         return toReal(val)
 */
  __pyx_v_val = 0.0;

  /* "SLEPc/EPS.pyx":2544
 *         """
 *         cdef PetscReal val = 0
 *         CHKERR( EPSLOBPCGGetRestart(self.eps, &val) )             # <<<<<<<<<<<<<<
 *         return toReal(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSLOBPCGGetRestart(__pyx_v_self->eps, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2544, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2545
 *         cdef PetscReal val = 0
 *         CHKERR( EPSLOBPCGGetRestart(self.eps, &val) )
 *         return toReal(val)             # <<<<<<<<<<<<<<
 * 
 *     def setLOBPCGLocking(self, lock):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2545, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2534
 *         CHKERR( EPSLOBPCGSetRestart(self.eps, val) )
 * 
 *     def getLOBPCGRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the restart parameter used in the LOBPCG method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getLOBPCGRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2547
 *         return toReal(val)
 * 
 *     def setLOBPCGLocking(self, lock):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between locking and non-locking variants of the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_263setLOBPCGLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_262setLOBPCGLocking[] = "EPS.setLOBPCGLocking(self, lock)\n\n        Choose between locking and non-locking variants of the\n        LOBPCG method.\n\n        Parameters\n        ----------\n        lock: bool\n              True if the locking variant must be selected.\n\n        Notes\n        -----\n        This flag refers to soft locking (converged vectors within the current\n        block iterate), since hard locking is always used (when nev is larger\n        than the block size).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_263setLOBPCGLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_lock = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setLOBPCGLocking (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lock,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lock)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setLOBPCGLocking") < 0)) __PYX_ERR(17, 2547, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_lock = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setLOBPCGLocking", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2547, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setLOBPCGLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_262setLOBPCGLocking(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_lock);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_262setLOBPCGLocking(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_lock) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setLOBPCGLocking", 0);

  /* "SLEPc/EPS.pyx":2563
 *         than the block size).
 *         """
 *         cdef PetscBool val = asBool(lock)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSLOBPCGSetLocking(self.eps, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_lock); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 2563, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2564
 *         """
 *         cdef PetscBool val = asBool(lock)
 *         CHKERR( EPSLOBPCGSetLocking(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getLOBPCGLocking(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSLOBPCGSetLocking(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2564, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2547
 *         return toReal(val)
 * 
 *     def setLOBPCGLocking(self, lock):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between locking and non-locking variants of the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setLOBPCGLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2566
 *         CHKERR( EPSLOBPCGSetLocking(self.eps, val) )
 * 
 *     def getLOBPCGLocking(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the locking flag used in the LOBPCG method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_265getLOBPCGLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_264getLOBPCGLocking[] = "EPS.getLOBPCGLocking(self)\n\n        Gets the locking flag used in the LOBPCG method.\n\n        Returns\n        -------\n        lock: bool\n              The locking flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_265getLOBPCGLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getLOBPCGLocking (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getLOBPCGLocking", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLOBPCGLocking", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_264getLOBPCGLocking(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_264getLOBPCGLocking(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getLOBPCGLocking", 0);

  /* "SLEPc/EPS.pyx":2575
 *               The locking flag.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSLOBPCGGetLocking(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":2576
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSLOBPCGGetLocking(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSLOBPCGGetLocking(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2576, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2577
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSLOBPCGGetLocking(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setLyapIIRanks(self, rkc=None, rkl=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2577, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2566
 *         CHKERR( EPSLOBPCGSetLocking(self.eps, val) )
 * 
 *     def getLOBPCGLocking(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the locking flag used in the LOBPCG method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getLOBPCGLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2579
 *         return toBool(tval)
 * 
 *     def setLyapIIRanks(self, rkc=None, rkl=None):             # <<<<<<<<<<<<<<
 *         """
 *         Set the ranks used in the solution of the Lyapunov equation.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_267setLyapIIRanks(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_266setLyapIIRanks[] = "EPS.setLyapIIRanks(self, rkc=None, rkl=None)\n\n        Set the ranks used in the solution of the Lyapunov equation.\n\n        Parameters\n        ----------\n        rkc: int, optional\n             The compressed rank.\n        rkl: int, optional\n             The Lyapunov rank.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_267setLyapIIRanks(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_rkc = 0;
  PyObject *__pyx_v_rkl = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setLyapIIRanks (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rkc,&__pyx_n_s_rkl,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rkc);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rkl);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setLyapIIRanks") < 0)) __PYX_ERR(17, 2579, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_rkc = values[0];
    __pyx_v_rkl = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setLyapIIRanks", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2579, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setLyapIIRanks", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_266setLyapIIRanks(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_rkc, __pyx_v_rkl);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_266setLyapIIRanks(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_rkc, PyObject *__pyx_v_rkl) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setLyapIIRanks", 0);

  /* "SLEPc/EPS.pyx":2590
 *              The Lyapunov rank.
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if rkc  is not None: ival1 = asInt(rkc)
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2591
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if rkc  is not None: ival1 = asInt(rkc)
 *         if rkl is not None: ival2 = asInt(rkl)
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2592
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if rkc  is not None: ival1 = asInt(rkc)             # <<<<<<<<<<<<<<
 *         if rkl is not None: ival2 = asInt(rkl)
 *         CHKERR( EPSLyapIISetRanks(self.eps, ival1, ival2) )
 */
  __pyx_t_1 = (__pyx_v_rkc != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_rkc); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2592, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":2593
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if rkc  is not None: ival1 = asInt(rkc)
 *         if rkl is not None: ival2 = asInt(rkl)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSLyapIISetRanks(self.eps, ival1, ival2) )
 * 
 */
  __pyx_t_2 = (__pyx_v_rkl != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_rkl); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2593, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":2594
 *         if rkc  is not None: ival1 = asInt(rkc)
 *         if rkl is not None: ival2 = asInt(rkl)
 *         CHKERR( EPSLyapIISetRanks(self.eps, ival1, ival2) )             # <<<<<<<<<<<<<<
 * 
 *     def getLyapIIRanks(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSLyapIISetRanks(__pyx_v_self->eps, __pyx_v_ival1, __pyx_v_ival2)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(17, 2594, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2579
 *         return toBool(tval)
 * 
 *     def setLyapIIRanks(self, rkc=None, rkl=None):             # <<<<<<<<<<<<<<
 *         """
 *         Set the ranks used in the solution of the Lyapunov equation.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setLyapIIRanks", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2596
 *         CHKERR( EPSLyapIISetRanks(self.eps, ival1, ival2) )
 * 
 *     def getLyapIIRanks(self):             # <<<<<<<<<<<<<<
 *         """
 *         Return the rank values used for the Lyapunov step.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_269getLyapIIRanks(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_268getLyapIIRanks[] = "EPS.getLyapIIRanks(self)\n\n        Return the rank values used for the Lyapunov step.\n\n        Returns\n        -------\n        rkc: int\n             The compressed rank.\n        rkl: int\n             The Lyapunov rank.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_269getLyapIIRanks(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getLyapIIRanks (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getLyapIIRanks", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLyapIIRanks", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_268getLyapIIRanks(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_268getLyapIIRanks(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getLyapIIRanks", 0);

  /* "SLEPc/EPS.pyx":2607
 *              The Lyapunov rank.
 *         """
 *         cdef PetscInt ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         CHKERR( EPSLyapIIGetRanks(self.eps, &ival1, &ival2) )
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/EPS.pyx":2608
 *         """
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSLyapIIGetRanks(self.eps, &ival1, &ival2) )
 *         return (toInt(ival1), toInt(ival2))
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/EPS.pyx":2609
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0
 *         CHKERR( EPSLyapIIGetRanks(self.eps, &ival1, &ival2) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSLyapIIGetRanks(__pyx_v_self->eps, (&__pyx_v_ival1), (&__pyx_v_ival2))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2609, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2610
 *         cdef PetscInt ival2 = 0
 *         CHKERR( EPSLyapIIGetRanks(self.eps, &ival1, &ival2) )
 *         return (toInt(ival1), toInt(ival2))             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2610, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 2610, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 2610, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2596
 *         CHKERR( EPSLyapIISetRanks(self.eps, ival1, ival2) )
 * 
 *     def getLyapIIRanks(self):             # <<<<<<<<<<<<<<
 *         """
 *         Return the rank values used for the Lyapunov step.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getLyapIIRanks", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2614
 *     #
 * 
 *     def setCISSExtraction(self, extraction):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the extraction technique used in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_271setCISSExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_270setCISSExtraction[] = "EPS.setCISSExtraction(self, extraction)\n\n        Sets the extraction technique used in the CISS solver.\n\n        Parameters\n        ----------\n        extraction: `EPS.CISSExtraction` enumerate\n               The extraction technique.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_271setCISSExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_extraction = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCISSExtraction (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_extraction,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_extraction)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCISSExtraction") < 0)) __PYX_ERR(17, 2614, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_extraction = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCISSExtraction", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2614, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setCISSExtraction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_270setCISSExtraction(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_extraction);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_270setCISSExtraction(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_extraction) {
  EPSCISSExtraction __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  EPSCISSExtraction __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCISSExtraction", 0);

  /* "SLEPc/EPS.pyx":2623
 *                The extraction technique.
 *         """
 *         cdef SlepcEPSCISSExtraction val = extraction             # <<<<<<<<<<<<<<
 *         CHKERR( EPSCISSSetExtraction(self.eps, val) )
 * 
 */
  __pyx_t_1 = ((EPSCISSExtraction)__Pyx_PyInt_As_EPSCISSExtraction(__pyx_v_extraction)); if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 2623, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2624
 *         """
 *         cdef SlepcEPSCISSExtraction val = extraction
 *         CHKERR( EPSCISSSetExtraction(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getCISSExtraction(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSCISSSetExtraction(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2624, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2614
 *     #
 * 
 *     def setCISSExtraction(self, extraction):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the extraction technique used in the CISS solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setCISSExtraction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2626
 *         CHKERR( EPSCISSSetExtraction(self.eps, val) )
 * 
 *     def getCISSExtraction(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the extraction technique used in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_273getCISSExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_272getCISSExtraction[] = "EPS.getCISSExtraction(self)\n\n        Gets the extraction technique used in the CISS solver.\n\n        Returns\n        -------\n        extraction: `EPS.CISSExtraction` enumerate\n               The extraction technique.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_273getCISSExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSExtraction (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSExtraction", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSExtraction", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_272getCISSExtraction(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_272getCISSExtraction(struct PySlepcEPSObject *__pyx_v_self) {
  EPSCISSExtraction __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSExtraction", 0);

  /* "SLEPc/EPS.pyx":2635
 *                The extraction technique.
 *         """
 *         cdef SlepcEPSCISSExtraction val = EPS_CISS_EXTRACTION_RITZ             # <<<<<<<<<<<<<<
 *         CHKERR( EPSCISSGetExtraction(self.eps, &val) )
 *         return val
 */
  __pyx_v_val = EPS_CISS_EXTRACTION_RITZ;

  /* "SLEPc/EPS.pyx":2636
 *         """
 *         cdef SlepcEPSCISSExtraction val = EPS_CISS_EXTRACTION_RITZ
 *         CHKERR( EPSCISSGetExtraction(self.eps, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSCISSGetExtraction(__pyx_v_self->eps, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2636, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2637
 *         cdef SlepcEPSCISSExtraction val = EPS_CISS_EXTRACTION_RITZ
 *         CHKERR( EPSCISSGetExtraction(self.eps, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setCISSQuadRule(self, quad):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_EPSCISSExtraction(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2637, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2626
 *         CHKERR( EPSCISSSetExtraction(self.eps, val) )
 * 
 *     def getCISSExtraction(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the extraction technique used in the CISS solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getCISSExtraction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2639
 *         return val
 * 
 *     def setCISSQuadRule(self, quad):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the quadrature rule used in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_275setCISSQuadRule(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_274setCISSQuadRule[] = "EPS.setCISSQuadRule(self, quad)\n\n        Sets the quadrature rule used in the CISS solver.\n\n        Parameters\n        ----------\n        quad: `EPS.CISSQuadRule` enumerate\n               The quadrature rule.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_275setCISSQuadRule(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_quad = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCISSQuadRule (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_quad,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_quad)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCISSQuadRule") < 0)) __PYX_ERR(17, 2639, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_quad = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCISSQuadRule", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2639, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setCISSQuadRule", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_274setCISSQuadRule(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_quad);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_274setCISSQuadRule(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_quad) {
  EPSCISSQuadRule __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  EPSCISSQuadRule __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCISSQuadRule", 0);

  /* "SLEPc/EPS.pyx":2648
 *                The quadrature rule.
 *         """
 *         cdef SlepcEPSCISSQuadRule val = quad             # <<<<<<<<<<<<<<
 *         CHKERR( EPSCISSSetQuadRule(self.eps, val) )
 * 
 */
  __pyx_t_1 = ((EPSCISSQuadRule)__Pyx_PyInt_As_EPSCISSQuadRule(__pyx_v_quad)); if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 2648, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2649
 *         """
 *         cdef SlepcEPSCISSQuadRule val = quad
 *         CHKERR( EPSCISSSetQuadRule(self.eps, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getCISSQuadRule(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSCISSSetQuadRule(__pyx_v_self->eps, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2649, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2639
 *         return val
 * 
 *     def setCISSQuadRule(self, quad):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the quadrature rule used in the CISS solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setCISSQuadRule", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2651
 *         CHKERR( EPSCISSSetQuadRule(self.eps, val) )
 * 
 *     def getCISSQuadRule(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the quadrature rule used in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_277getCISSQuadRule(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_276getCISSQuadRule[] = "EPS.getCISSQuadRule(self)\n\n        Gets the quadrature rule used in the CISS solver.\n\n        Returns\n        -------\n        quad: `EPS.CISSQuadRule` enumerate\n               The quadrature rule.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_277getCISSQuadRule(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSQuadRule (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSQuadRule", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSQuadRule", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_276getCISSQuadRule(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_276getCISSQuadRule(struct PySlepcEPSObject *__pyx_v_self) {
  EPSCISSQuadRule __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSQuadRule", 0);

  /* "SLEPc/EPS.pyx":2660
 *                The quadrature rule.
 *         """
 *         cdef SlepcEPSCISSQuadRule val = EPS_CISS_QUADRULE_TRAPEZOIDAL             # <<<<<<<<<<<<<<
 *         CHKERR( EPSCISSGetQuadRule(self.eps, &val) )
 *         return val
 */
  __pyx_v_val = EPS_CISS_QUADRULE_TRAPEZOIDAL;

  /* "SLEPc/EPS.pyx":2661
 *         """
 *         cdef SlepcEPSCISSQuadRule val = EPS_CISS_QUADRULE_TRAPEZOIDAL
 *         CHKERR( EPSCISSGetQuadRule(self.eps, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSCISSGetQuadRule(__pyx_v_self->eps, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2661, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2662
 *         cdef SlepcEPSCISSQuadRule val = EPS_CISS_QUADRULE_TRAPEZOIDAL
 *         CHKERR( EPSCISSGetQuadRule(self.eps, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setCISSSizes(self, ip=None, bs=None, ms=None, npart=None, bsmax=None, realmats=False):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_EPSCISSQuadRule(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2662, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2651
 *         CHKERR( EPSCISSSetQuadRule(self.eps, val) )
 * 
 *     def getCISSQuadRule(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the quadrature rule used in the CISS solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getCISSQuadRule", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2664
 *         return val
 * 
 *     def setCISSSizes(self, ip=None, bs=None, ms=None, npart=None, bsmax=None, realmats=False):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various size parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_279setCISSSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_278setCISSSizes[] = "EPS.setCISSSizes(self, ip=None, bs=None, ms=None, npart=None, bsmax=None, realmats=False)\n\n        Sets the values of various size parameters in the CISS solver.\n\n        Parameters\n        ----------\n        ip: int, optional\n             Number of integration points.\n        bs: int, optional\n             Block size.\n        ms: int, optional\n             Moment size.\n        npart: int, optional\n             Number of partitions when splitting the communicator.\n        bsmax: int, optional\n             Maximum block size.\n        realmats: bool, optional\n             True if A and B are real.\n\n        Notes\n        -----\n        The default number of partitions is 1. This means the internal `KSP` object\n        is shared among all processes of the `EPS` communicator. Otherwise, the\n        communicator is split into npart communicators, so that `npart` `KSP` solves\n        proceed simultaneously.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_279setCISSSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_ip = 0;
  PyObject *__pyx_v_bs = 0;
  PyObject *__pyx_v_ms = 0;
  PyObject *__pyx_v_npart = 0;
  PyObject *__pyx_v_bsmax = 0;
  PyObject *__pyx_v_realmats = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCISSSizes (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ip,&__pyx_n_s_bs,&__pyx_n_s_ms,&__pyx_n_s_npart,&__pyx_n_s_bsmax,&__pyx_n_s_realmats,0};
    PyObject* values[6] = {0,0,0,0,0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    values[3] = ((PyObject *)Py_None);
    values[4] = ((PyObject *)Py_None);
    values[5] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ip);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bs);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ms);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_npart);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bsmax);
          if (value) { values[4] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_realmats);
          if (value) { values[5] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCISSSizes") < 0)) __PYX_ERR(17, 2664, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_ip = values[0];
    __pyx_v_bs = values[1];
    __pyx_v_ms = values[2];
    __pyx_v_npart = values[3];
    __pyx_v_bsmax = values[4];
    __pyx_v_realmats = values[5];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCISSSizes", 0, 0, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2664, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setCISSSizes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_278setCISSSizes(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_ip, __pyx_v_bs, __pyx_v_ms, __pyx_v_npart, __pyx_v_bsmax, __pyx_v_realmats);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_278setCISSSizes(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_ip, PyObject *__pyx_v_bs, PyObject *__pyx_v_ms, PyObject *__pyx_v_npart, PyObject *__pyx_v_bsmax, PyObject *__pyx_v_realmats) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PetscInt __pyx_v_ival4;
  PetscInt __pyx_v_ival5;
  PetscBool __pyx_v_bval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PetscInt __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCISSSizes", 0);

  /* "SLEPc/EPS.pyx":2690
 *         proceed simultaneously.
 *         """
 *         cdef PetscInt  ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival2 = PETSC_DEFAULT
 *         cdef PetscInt  ival3 = PETSC_DEFAULT
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2691
 *         """
 *         cdef PetscInt  ival1 = PETSC_DEFAULT
 *         cdef PetscInt  ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival3 = PETSC_DEFAULT
 *         cdef PetscInt  ival4 = PETSC_DEFAULT
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2692
 *         cdef PetscInt  ival1 = PETSC_DEFAULT
 *         cdef PetscInt  ival2 = PETSC_DEFAULT
 *         cdef PetscInt  ival3 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival4 = PETSC_DEFAULT
 *         cdef PetscInt  ival5 = PETSC_DEFAULT
 */
  __pyx_v_ival3 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2693
 *         cdef PetscInt  ival2 = PETSC_DEFAULT
 *         cdef PetscInt  ival3 = PETSC_DEFAULT
 *         cdef PetscInt  ival4 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival5 = PETSC_DEFAULT
 *         cdef PetscBool bval  = asBool(realmats)
 */
  __pyx_v_ival4 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2694
 *         cdef PetscInt  ival3 = PETSC_DEFAULT
 *         cdef PetscInt  ival4 = PETSC_DEFAULT
 *         cdef PetscInt  ival5 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscBool bval  = asBool(realmats)
 *         if ip    is not None: ival1 = asInt(ip)
 */
  __pyx_v_ival5 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2695
 *         cdef PetscInt  ival4 = PETSC_DEFAULT
 *         cdef PetscInt  ival5 = PETSC_DEFAULT
 *         cdef PetscBool bval  = asBool(realmats)             # <<<<<<<<<<<<<<
 *         if ip    is not None: ival1 = asInt(ip)
 *         if bs    is not None: ival2 = asInt(bs)
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_realmats); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 2695, __pyx_L1_error)
  __pyx_v_bval = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2696
 *         cdef PetscInt  ival5 = PETSC_DEFAULT
 *         cdef PetscBool bval  = asBool(realmats)
 *         if ip    is not None: ival1 = asInt(ip)             # <<<<<<<<<<<<<<
 *         if bs    is not None: ival2 = asInt(bs)
 *         if ms    is not None: ival3 = asInt(ms)
 */
  __pyx_t_2 = (__pyx_v_ip != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_ip); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2696, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_4;
  }

  /* "SLEPc/EPS.pyx":2697
 *         cdef PetscBool bval  = asBool(realmats)
 *         if ip    is not None: ival1 = asInt(ip)
 *         if bs    is not None: ival2 = asInt(bs)             # <<<<<<<<<<<<<<
 *         if ms    is not None: ival3 = asInt(ms)
 *         if npart is not None: ival4 = asInt(npart)
 */
  __pyx_t_3 = (__pyx_v_bs != Py_None);
  __pyx_t_2 = (__pyx_t_3 != 0);
  if (__pyx_t_2) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_bs); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2697, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_4;
  }

  /* "SLEPc/EPS.pyx":2698
 *         if ip    is not None: ival1 = asInt(ip)
 *         if bs    is not None: ival2 = asInt(bs)
 *         if ms    is not None: ival3 = asInt(ms)             # <<<<<<<<<<<<<<
 *         if npart is not None: ival4 = asInt(npart)
 *         if bsmax is not None: ival5 = asInt(bsmax)
 */
  __pyx_t_2 = (__pyx_v_ms != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_ms); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2698, __pyx_L1_error)
    __pyx_v_ival3 = __pyx_t_4;
  }

  /* "SLEPc/EPS.pyx":2699
 *         if bs    is not None: ival2 = asInt(bs)
 *         if ms    is not None: ival3 = asInt(ms)
 *         if npart is not None: ival4 = asInt(npart)             # <<<<<<<<<<<<<<
 *         if bsmax is not None: ival5 = asInt(bsmax)
 *         CHKERR( EPSCISSSetSizes(self.eps, ival1, ival2, ival3, ival4, ival5, bval) )
 */
  __pyx_t_3 = (__pyx_v_npart != Py_None);
  __pyx_t_2 = (__pyx_t_3 != 0);
  if (__pyx_t_2) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_npart); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2699, __pyx_L1_error)
    __pyx_v_ival4 = __pyx_t_4;
  }

  /* "SLEPc/EPS.pyx":2700
 *         if ms    is not None: ival3 = asInt(ms)
 *         if npart is not None: ival4 = asInt(npart)
 *         if bsmax is not None: ival5 = asInt(bsmax)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSCISSSetSizes(self.eps, ival1, ival2, ival3, ival4, ival5, bval) )
 * 
 */
  __pyx_t_2 = (__pyx_v_bsmax != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_bsmax); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2700, __pyx_L1_error)
    __pyx_v_ival5 = __pyx_t_4;
  }

  /* "SLEPc/EPS.pyx":2701
 *         if npart is not None: ival4 = asInt(npart)
 *         if bsmax is not None: ival5 = asInt(bsmax)
 *         CHKERR( EPSCISSSetSizes(self.eps, ival1, ival2, ival3, ival4, ival5, bval) )             # <<<<<<<<<<<<<<
 * 
 *     def getCISSSizes(self):
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSCISSSetSizes(__pyx_v_self->eps, __pyx_v_ival1, __pyx_v_ival2, __pyx_v_ival3, __pyx_v_ival4, __pyx_v_ival5, __pyx_v_bval)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(17, 2701, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2664
 *         return val
 * 
 *     def setCISSSizes(self, ip=None, bs=None, ms=None, npart=None, bsmax=None, realmats=False):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various size parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setCISSSizes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2703
 *         CHKERR( EPSCISSSetSizes(self.eps, ival1, ival2, ival3, ival4, ival5, bval) )
 * 
 *     def getCISSSizes(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various size parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_281getCISSSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_280getCISSSizes[] = "EPS.getCISSSizes(self)\n\n        Gets the values of various size parameters in the CISS solver.\n\n        Returns\n        -------\n        ip: int\n             Number of integration points.\n        bs: int\n             Block size.\n        ms: int\n             Moment size.\n        npart: int\n             Number of partitions when splitting the communicator.\n        bsmax: int\n             Maximum block size.\n        realmats: bool\n             True if A and B are real.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_281getCISSSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSSizes (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSSizes", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSSizes", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_280getCISSSizes(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_280getCISSSizes(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PetscInt __pyx_v_ival4;
  PetscInt __pyx_v_ival5;
  PetscBool __pyx_v_bval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSSizes", 0);

  /* "SLEPc/EPS.pyx":2722
 *              True if A and B are real.
 *         """
 *         cdef PetscInt  ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival2 = 0
 *         cdef PetscInt  ival3 = 0
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/EPS.pyx":2723
 *         """
 *         cdef PetscInt  ival1 = 0
 *         cdef PetscInt  ival2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival3 = 0
 *         cdef PetscInt  ival4 = 0
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/EPS.pyx":2724
 *         cdef PetscInt  ival1 = 0
 *         cdef PetscInt  ival2 = 0
 *         cdef PetscInt  ival3 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival4 = 0
 *         cdef PetscInt  ival5 = 0
 */
  __pyx_v_ival3 = 0;

  /* "SLEPc/EPS.pyx":2725
 *         cdef PetscInt  ival2 = 0
 *         cdef PetscInt  ival3 = 0
 *         cdef PetscInt  ival4 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival5 = 0
 *         cdef PetscBool bval  = PETSC_FALSE
 */
  __pyx_v_ival4 = 0;

  /* "SLEPc/EPS.pyx":2726
 *         cdef PetscInt  ival3 = 0
 *         cdef PetscInt  ival4 = 0
 *         cdef PetscInt  ival5 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscBool bval  = PETSC_FALSE
 *         CHKERR( EPSCISSGetSizes(self.eps, &ival1, &ival2, &ival3, &ival4, &ival5, &bval) )
 */
  __pyx_v_ival5 = 0;

  /* "SLEPc/EPS.pyx":2727
 *         cdef PetscInt  ival4 = 0
 *         cdef PetscInt  ival5 = 0
 *         cdef PetscBool bval  = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSCISSGetSizes(self.eps, &ival1, &ival2, &ival3, &ival4, &ival5, &bval) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))
 */
  __pyx_v_bval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":2728
 *         cdef PetscInt  ival5 = 0
 *         cdef PetscBool bval  = PETSC_FALSE
 *         CHKERR( EPSCISSGetSizes(self.eps, &ival1, &ival2, &ival3, &ival4, &ival5, &bval) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSCISSGetSizes(__pyx_v_self->eps, (&__pyx_v_ival1), (&__pyx_v_ival2), (&__pyx_v_ival3), (&__pyx_v_ival4), (&__pyx_v_ival5), (&__pyx_v_bval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2728, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2729
 *         cdef PetscBool bval  = PETSC_FALSE
 *         CHKERR( EPSCISSGetSizes(self.eps, &ival1, &ival2, &ival3, &ival4, &ival5, &bval) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))             # <<<<<<<<<<<<<<
 * 
 *     def setCISSThreshold(self, delta=None, spur=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2729, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 2729, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival3); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 2729, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival4); if (unlikely(!__pyx_t_5)) __PYX_ERR(17, 2729, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival5); if (unlikely(!__pyx_t_6)) __PYX_ERR(17, 2729, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_bval); if (unlikely(!__pyx_t_7)) __PYX_ERR(17, 2729, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = PyTuple_New(6); if (unlikely(!__pyx_t_8)) __PYX_ERR(17, 2729, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_7);
  PyTuple_SET_ITEM(__pyx_t_8, 5, __pyx_t_7);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_t_6 = 0;
  __pyx_t_7 = 0;
  __pyx_r = __pyx_t_8;
  __pyx_t_8 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2703
 *         CHKERR( EPSCISSSetSizes(self.eps, ival1, ival2, ival3, ival4, ival5, bval) )
 * 
 *     def getCISSSizes(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various size parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getCISSSizes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2731
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))
 * 
 *     def setCISSThreshold(self, delta=None, spur=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various threshold parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_283setCISSThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_282setCISSThreshold[] = "EPS.setCISSThreshold(self, delta=None, spur=None)\n\n        Sets the values of various threshold parameters in the CISS solver.\n\n        Parameters\n        ----------\n        delta: float\n                Threshold for numerical rank.\n        spur: float\n                Spurious threshold (to discard spurious eigenpairs).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_283setCISSThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_delta = 0;
  PyObject *__pyx_v_spur = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCISSThreshold (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_delta,&__pyx_n_s_spur,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_spur);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCISSThreshold") < 0)) __PYX_ERR(17, 2731, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_delta = values[0];
    __pyx_v_spur = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCISSThreshold", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2731, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setCISSThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_282setCISSThreshold(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_delta, __pyx_v_spur);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_282setCISSThreshold(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_delta, PyObject *__pyx_v_spur) {
  PetscReal __pyx_v_rval1;
  PetscReal __pyx_v_rval2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscReal __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCISSThreshold", 0);

  /* "SLEPc/EPS.pyx":2742
 *                 Spurious threshold (to discard spurious eigenpairs).
 *         """
 *         cdef PetscReal rval1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval2 = PETSC_DEFAULT
 *         if delta is not None: rval1 = asReal(delta)
 */
  __pyx_v_rval1 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2743
 *         """
 *         cdef PetscReal rval1 = PETSC_DEFAULT
 *         cdef PetscReal rval2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if delta is not None: rval1 = asReal(delta)
 *         if spur  is not None: rval2 = asReal(spur)
 */
  __pyx_v_rval2 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2744
 *         cdef PetscReal rval1 = PETSC_DEFAULT
 *         cdef PetscReal rval2 = PETSC_DEFAULT
 *         if delta is not None: rval1 = asReal(delta)             # <<<<<<<<<<<<<<
 *         if spur  is not None: rval2 = asReal(spur)
 *         CHKERR( EPSCISSSetThreshold(self.eps, rval1, rval2) )
 */
  __pyx_t_1 = (__pyx_v_delta != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_delta); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(17, 2744, __pyx_L1_error)
    __pyx_v_rval1 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":2745
 *         cdef PetscReal rval2 = PETSC_DEFAULT
 *         if delta is not None: rval1 = asReal(delta)
 *         if spur  is not None: rval2 = asReal(spur)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSCISSSetThreshold(self.eps, rval1, rval2) )
 * 
 */
  __pyx_t_2 = (__pyx_v_spur != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_spur); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(17, 2745, __pyx_L1_error)
    __pyx_v_rval2 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":2746
 *         if delta is not None: rval1 = asReal(delta)
 *         if spur  is not None: rval2 = asReal(spur)
 *         CHKERR( EPSCISSSetThreshold(self.eps, rval1, rval2) )             # <<<<<<<<<<<<<<
 * 
 *     def getCISSThreshold(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSCISSSetThreshold(__pyx_v_self->eps, __pyx_v_rval1, __pyx_v_rval2)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(17, 2746, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2731
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))
 * 
 *     def setCISSThreshold(self, delta=None, spur=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various threshold parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setCISSThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2748
 *         CHKERR( EPSCISSSetThreshold(self.eps, rval1, rval2) )
 * 
 *     def getCISSThreshold(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various threshold parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_285getCISSThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_284getCISSThreshold[] = "EPS.getCISSThreshold(self)\n\n        Gets the values of various threshold parameters in the CISS solver.\n\n        Returns\n        -------\n        delta: float\n                Threshold for numerical rank.\n        spur: float\n                Spurious threshold (to discard spurious eigenpairs.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_285getCISSThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSThreshold (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSThreshold", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSThreshold", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_284getCISSThreshold(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_284getCISSThreshold(struct PySlepcEPSObject *__pyx_v_self) {
  PetscReal __pyx_v_delta;
  PetscReal __pyx_v_spur;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSThreshold", 0);

  /* "SLEPc/EPS.pyx":2759
 *                 Spurious threshold (to discard spurious eigenpairs.
 *         """
 *         cdef PetscReal delta = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal spur  = 0
 *         CHKERR( EPSCISSGetThreshold(self.eps, &delta, &spur) )
 */
  __pyx_v_delta = 0.0;

  /* "SLEPc/EPS.pyx":2760
 *         """
 *         cdef PetscReal delta = 0
 *         cdef PetscReal spur  = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSCISSGetThreshold(self.eps, &delta, &spur) )
 *         return (toReal(delta), toReal(spur))
 */
  __pyx_v_spur = 0.0;

  /* "SLEPc/EPS.pyx":2761
 *         cdef PetscReal delta = 0
 *         cdef PetscReal spur  = 0
 *         CHKERR( EPSCISSGetThreshold(self.eps, &delta, &spur) )             # <<<<<<<<<<<<<<
 *         return (toReal(delta), toReal(spur))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSCISSGetThreshold(__pyx_v_self->eps, (&__pyx_v_delta), (&__pyx_v_spur))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2761, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2762
 *         cdef PetscReal spur  = 0
 *         CHKERR( EPSCISSGetThreshold(self.eps, &delta, &spur) )
 *         return (toReal(delta), toReal(spur))             # <<<<<<<<<<<<<<
 * 
 *     def setCISSRefinement(self, inner=None, blsize=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_delta); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2762, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_spur); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 2762, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 2762, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2748
 *         CHKERR( EPSCISSSetThreshold(self.eps, rval1, rval2) )
 * 
 *     def getCISSThreshold(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various threshold parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getCISSThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2764
 *         return (toReal(delta), toReal(spur))
 * 
 *     def setCISSRefinement(self, inner=None, blsize=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various refinement parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_287setCISSRefinement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_286setCISSRefinement[] = "EPS.setCISSRefinement(self, inner=None, blsize=None)\n\n        Sets the values of various refinement parameters in the CISS solver.\n\n        Parameters\n        ----------\n        inner: int, optional\n             Number of iterative refinement iterations (inner loop).\n        blsize: int, optional\n             Number of iterative refinement iterations (blocksize loop).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_287setCISSRefinement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_inner = 0;
  PyObject *__pyx_v_blsize = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCISSRefinement (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inner,&__pyx_n_s_blsize,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_inner);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_blsize);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCISSRefinement") < 0)) __PYX_ERR(17, 2764, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_inner = values[0];
    __pyx_v_blsize = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCISSRefinement", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2764, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setCISSRefinement", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_286setCISSRefinement(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_inner, __pyx_v_blsize);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_286setCISSRefinement(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_inner, PyObject *__pyx_v_blsize) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCISSRefinement", 0);

  /* "SLEPc/EPS.pyx":2775
 *              Number of iterative refinement iterations (blocksize loop).
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if inner  is not None: ival1 = asInt(inner)
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2776
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if inner  is not None: ival1 = asInt(inner)
 *         if blsize is not None: ival2 = asInt(blsize)
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/EPS.pyx":2777
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if inner  is not None: ival1 = asInt(inner)             # <<<<<<<<<<<<<<
 *         if blsize is not None: ival2 = asInt(blsize)
 *         CHKERR( EPSCISSSetRefinement(self.eps, ival1, ival2) )
 */
  __pyx_t_1 = (__pyx_v_inner != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_inner); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2777, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":2778
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if inner  is not None: ival1 = asInt(inner)
 *         if blsize is not None: ival2 = asInt(blsize)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSCISSSetRefinement(self.eps, ival1, ival2) )
 * 
 */
  __pyx_t_2 = (__pyx_v_blsize != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_blsize); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(17, 2778, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_3;
  }

  /* "SLEPc/EPS.pyx":2779
 *         if inner  is not None: ival1 = asInt(inner)
 *         if blsize is not None: ival2 = asInt(blsize)
 *         CHKERR( EPSCISSSetRefinement(self.eps, ival1, ival2) )             # <<<<<<<<<<<<<<
 * 
 *     def getCISSRefinement(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSCISSSetRefinement(__pyx_v_self->eps, __pyx_v_ival1, __pyx_v_ival2)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(17, 2779, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2764
 *         return (toReal(delta), toReal(spur))
 * 
 *     def setCISSRefinement(self, inner=None, blsize=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various refinement parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setCISSRefinement", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2781
 *         CHKERR( EPSCISSSetRefinement(self.eps, ival1, ival2) )
 * 
 *     def getCISSRefinement(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various refinement parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_289getCISSRefinement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_288getCISSRefinement[] = "EPS.getCISSRefinement(self)\n\n        Gets the values of various refinement parameters in the CISS solver.\n\n        Returns\n        -------\n        inner: int\n             Number of iterative refinement iterations (inner loop).\n        blsize: int\n             Number of iterative refinement iterations (blocksize loop).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_289getCISSRefinement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSRefinement (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSRefinement", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSRefinement", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_288getCISSRefinement(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_288getCISSRefinement(struct PySlepcEPSObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSRefinement", 0);

  /* "SLEPc/EPS.pyx":2792
 *              Number of iterative refinement iterations (blocksize loop).
 *         """
 *         cdef PetscInt ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         CHKERR( EPSCISSGetRefinement(self.eps, &ival1, &ival2) )
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/EPS.pyx":2793
 *         """
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( EPSCISSGetRefinement(self.eps, &ival1, &ival2) )
 *         return (toInt(ival1), toInt(ival2))
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/EPS.pyx":2794
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0
 *         CHKERR( EPSCISSGetRefinement(self.eps, &ival1, &ival2) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSCISSGetRefinement(__pyx_v_self->eps, (&__pyx_v_ival1), (&__pyx_v_ival2))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2794, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2795
 *         cdef PetscInt ival2 = 0
 *         CHKERR( EPSCISSGetRefinement(self.eps, &ival1, &ival2) )
 *         return (toInt(ival1), toInt(ival2))             # <<<<<<<<<<<<<<
 * 
 *     def setCISSUseST(self, usest):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2795, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 2795, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 2795, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2781
 *         CHKERR( EPSCISSSetRefinement(self.eps, ival1, ival2) )
 * 
 *     def getCISSRefinement(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various refinement parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getCISSRefinement", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2797
 *         return (toInt(ival1), toInt(ival2))
 * 
 *     def setCISSUseST(self, usest):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag indicating that the CISS solver will use the `ST`
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_291setCISSUseST(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_290setCISSUseST[] = "EPS.setCISSUseST(self, usest)\n\n        Sets a flag indicating that the CISS solver will use the `ST`\n        object for the linear solves.\n\n        Parameters\n        ----------\n        usest: bool\n            Whether to use the `ST` object or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_291setCISSUseST(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_usest = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCISSUseST (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_usest,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_usest)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCISSUseST") < 0)) __PYX_ERR(17, 2797, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_usest = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCISSUseST", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 2797, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setCISSUseST", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_290setCISSUseST(((struct PySlepcEPSObject *)__pyx_v_self), __pyx_v_usest);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_290setCISSUseST(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_usest) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCISSUseST", 0);

  /* "SLEPc/EPS.pyx":2807
 *             Whether to use the `ST` object or not.
 *         """
 *         cdef PetscBool tval = asBool(usest)             # <<<<<<<<<<<<<<
 *         CHKERR( EPSCISSSetUseST(self.eps, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_usest); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(17, 2807, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/EPS.pyx":2808
 *         """
 *         cdef PetscBool tval = asBool(usest)
 *         CHKERR( EPSCISSSetUseST(self.eps, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getCISSUseST(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSCISSSetUseST(__pyx_v_self->eps, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(17, 2808, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2797
 *         return (toInt(ival1), toInt(ival2))
 * 
 *     def setCISSUseST(self, usest):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag indicating that the CISS solver will use the `ST`
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.setCISSUseST", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2810
 *         CHKERR( EPSCISSSetUseST(self.eps, tval) )
 * 
 *     def getCISSUseST(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the flag for using the `ST` object in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_293getCISSUseST(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_292getCISSUseST[] = "EPS.getCISSUseST(self)\n\n        Gets the flag for using the `ST` object in the CISS solver.\n\n        Returns\n        -------\n        usest: bool\n            Whether to use the `ST` object or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_293getCISSUseST(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSUseST (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSUseST", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSUseST", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_292getCISSUseST(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_292getCISSUseST(struct PySlepcEPSObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSUseST", 0);

  /* "SLEPc/EPS.pyx":2819
 *             Whether to use the `ST` object or not.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( EPSCISSGetUseST(self.eps, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/EPS.pyx":2820
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSCISSGetUseST(self.eps, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSCISSGetUseST(__pyx_v_self->eps, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2820, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2821
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( EPSCISSGetUseST(self.eps, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def getCISSKSPs(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2821, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2810
 *         CHKERR( EPSCISSSetUseST(self.eps, tval) )
 * 
 *     def getCISSUseST(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the flag for using the `ST` object in the CISS solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getCISSUseST", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2823
 *         return toBool(tval)
 * 
 *     def getCISSKSPs(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the array of linear solver objects associated with
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_295getCISSKSPs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3EPS_294getCISSKSPs[] = "EPS.getCISSKSPs(self)\n\n        Retrieve the array of linear solver objects associated with\n        the CISS solver.\n\n        Returns\n        -------\n        ksp: list of `KSP`\n             The linear solver objects.\n\n        Notes\n        -----\n        The number of `KSP` solvers is equal to the number of integration\n        points divided by the number of partitions. This value is halved in\n        the case of real matrices with a region centered at the real axis.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_295getCISSKSPs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSKSPs (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSKSPs", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSKSPs", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_294getCISSKSPs(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_294getCISSKSPs(struct PySlepcEPSObject *__pyx_v_self) {
  CYTHON_UNUSED PetscInt __pyx_v_i;
  PetscInt __pyx_v_n;
  KSP *__pyx_v_p;
  PetscInt __pyx_9genexpr13__pyx_v_i;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PetscInt __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSKSPs", 0);

  /* "SLEPc/EPS.pyx":2839
 *         the case of real matrices with a region centered at the real axis.
 *         """
 *         cdef PetscInt i = 0, n = 0             # <<<<<<<<<<<<<<
 *         cdef PetscKSP *p = NULL
 *         CHKERR( EPSCISSGetKSPs(self.eps, &n, &p) )
 */
  __pyx_v_i = 0;
  __pyx_v_n = 0;

  /* "SLEPc/EPS.pyx":2840
 *         """
 *         cdef PetscInt i = 0, n = 0
 *         cdef PetscKSP *p = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( EPSCISSGetKSPs(self.eps, &n, &p) )
 *         return [ref_KSP(p[i]) for i from 0 <= i <n]
 */
  __pyx_v_p = NULL;

  /* "SLEPc/EPS.pyx":2841
 *         cdef PetscInt i = 0, n = 0
 *         cdef PetscKSP *p = NULL
 *         CHKERR( EPSCISSGetKSPs(self.eps, &n, &p) )             # <<<<<<<<<<<<<<
 *         return [ref_KSP(p[i]) for i from 0 <= i <n]
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(EPSCISSGetKSPs(__pyx_v_self->eps, (&__pyx_v_n), (&__pyx_v_p))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(17, 2841, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2842
 *         cdef PetscKSP *p = NULL
 *         CHKERR( EPSCISSGetKSPs(self.eps, &n, &p) )
 *         return [ref_KSP(p[i]) for i from 0 <= i <n]             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  { /* enter inner scope */
    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2842, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __pyx_v_n;
    for (__pyx_9genexpr13__pyx_v_i = 0; __pyx_9genexpr13__pyx_v_i < __pyx_t_3; __pyx_9genexpr13__pyx_v_i++) {
      __pyx_t_4 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_KSP((__pyx_v_p[__pyx_9genexpr13__pyx_v_i]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 2842, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_4))) __PYX_ERR(17, 2842, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  } /* exit inner scope */
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2823
 *         return toBool(tval)
 * 
 *     def getCISSKSPs(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the array of linear solver objects associated with
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.getCISSKSPs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2846
 *     #
 *     property problem_type:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getProblemType()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_12problem_type_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_12problem_type_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_12problem_type___get__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_12problem_type___get__(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/EPS.pyx":2847
 *     property problem_type:
 *         def __get__(self):
 *             return self.getProblemType()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setProblemType(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getProblemType); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2847, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2847, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2846
 *     #
 *     property problem_type:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getProblemType()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.problem_type.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2848
 *         def __get__(self):
 *             return self.getProblemType()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setProblemType(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_12problem_type_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_12problem_type_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_12problem_type_2__set__(((struct PySlepcEPSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS_12problem_type_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/EPS.pyx":2849
 *             return self.getProblemType()
 *         def __set__(self, value):
 *             self.setProblemType(value)             # <<<<<<<<<<<<<<
 * 
 *     property extraction:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setProblemType); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2849, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2849, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":2848
 *         def __get__(self):
 *             return self.getProblemType()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setProblemType(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.problem_type.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2852
 * 
 *     property extraction:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getExtraction()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_10extraction_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_10extraction_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_10extraction___get__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_10extraction___get__(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/EPS.pyx":2853
 *     property extraction:
 *         def __get__(self):
 *             return self.getExtraction()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setExtraction(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getExtraction); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2853, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2853, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2852
 * 
 *     property extraction:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getExtraction()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.extraction.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2854
 *         def __get__(self):
 *             return self.getExtraction()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setExtraction(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_10extraction_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_10extraction_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_10extraction_2__set__(((struct PySlepcEPSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS_10extraction_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/EPS.pyx":2855
 *             return self.getExtraction()
 *         def __set__(self, value):
 *             self.setExtraction(value)             # <<<<<<<<<<<<<<
 * 
 *     property which:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setExtraction); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":2854
 *         def __get__(self):
 *             return self.getExtraction()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setExtraction(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.extraction.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2858
 * 
 *     property which:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_5which_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_5which_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_5which___get__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_5which___get__(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/EPS.pyx":2859
 *     property which:
 *         def __get__(self):
 *             return self.getWhichEigenpairs()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setWhichEigenpairs(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getWhichEigenpairs); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2859, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2859, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2858
 * 
 *     property which:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.which.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2860
 *         def __get__(self):
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setWhichEigenpairs(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_5which_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_5which_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_5which_2__set__(((struct PySlepcEPSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS_5which_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/EPS.pyx":2861
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):
 *             self.setWhichEigenpairs(value)             # <<<<<<<<<<<<<<
 * 
 *     property target:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setWhichEigenpairs); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2861, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2861, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":2860
 *         def __get__(self):
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setWhichEigenpairs(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.which.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2864
 * 
 *     property target:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTarget()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_6target_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_6target_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_6target___get__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_6target___get__(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/EPS.pyx":2865
 *     property target:
 *         def __get__(self):
 *             return self.getTarget()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTarget(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTarget); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2865, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2865, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2864
 * 
 *     property target:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTarget()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.target.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2866
 *         def __get__(self):
 *             return self.getTarget()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTarget(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_6target_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_6target_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_6target_2__set__(((struct PySlepcEPSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS_6target_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/EPS.pyx":2867
 *             return self.getTarget()
 *         def __set__(self, value):
 *             self.setTarget(value)             # <<<<<<<<<<<<<<
 * 
 *     property tol:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTarget); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2867, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2867, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":2866
 *         def __get__(self):
 *             return self.getTarget()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTarget(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.target.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2870
 * 
 *     property tol:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_3tol_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_3tol_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_3tol___get__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_3tol___get__(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/EPS.pyx":2871
 *     property tol:
 *         def __get__(self):
 *             return self.getTolerances()[0]             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTolerances(tol=value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTolerances); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2871, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2870
 * 
 *     property tol:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.tol.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2872
 *         def __get__(self):
 *             return self.getTolerances()[0]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(tol=value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_3tol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_3tol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_3tol_2__set__(((struct PySlepcEPSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS_3tol_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/EPS.pyx":2873
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 *             self.setTolerances(tol=value)             # <<<<<<<<<<<<<<
 * 
 *     property max_it:
 */
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTolerances); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2873, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2873, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_tol, __pyx_v_value) < 0) __PYX_ERR(17, 2873, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 2873, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/EPS.pyx":2872
 *         def __get__(self):
 *             return self.getTolerances()[0]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(tol=value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.tol.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2876
 * 
 *     property max_it:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_6max_it_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_6max_it_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_6max_it___get__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_6max_it___get__(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/EPS.pyx":2877
 *     property max_it:
 *         def __get__(self):
 *             return self.getTolerances()[1]             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTolerances(max_it=value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTolerances); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2877, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2877, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2877, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2876
 * 
 *     property max_it:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.max_it.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2878
 *         def __get__(self):
 *             return self.getTolerances()[1]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(max_it=value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_6max_it_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_6max_it_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_6max_it_2__set__(((struct PySlepcEPSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS_6max_it_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/EPS.pyx":2879
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 *             self.setTolerances(max_it=value)             # <<<<<<<<<<<<<<
 * 
 *     property two_sided:
 */
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTolerances); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_it, __pyx_v_value) < 0) __PYX_ERR(17, 2879, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 2879, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/EPS.pyx":2878
 *         def __get__(self):
 *             return self.getTolerances()[1]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(max_it=value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.max_it.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2882
 * 
 *     property two_sided:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTwoSided()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_9two_sided_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_9two_sided_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_9two_sided___get__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_9two_sided___get__(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/EPS.pyx":2883
 *     property two_sided:
 *         def __get__(self):
 *             return self.getTwoSided()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTwoSided(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTwoSided); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2882
 * 
 *     property two_sided:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTwoSided()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.two_sided.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2884
 *         def __get__(self):
 *             return self.getTwoSided()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTwoSided(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_9two_sided_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_9two_sided_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_9two_sided_2__set__(((struct PySlepcEPSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS_9two_sided_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/EPS.pyx":2885
 *             return self.getTwoSided()
 *         def __set__(self, value):
 *             self.setTwoSided(value)             # <<<<<<<<<<<<<<
 * 
 *     property true_residual:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTwoSided); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2885, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2885, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":2884
 *         def __get__(self):
 *             return self.getTwoSided()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTwoSided(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.two_sided.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2888
 * 
 *     property true_residual:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTrueResidual()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_13true_residual_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_13true_residual_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_13true_residual___get__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_13true_residual___get__(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/EPS.pyx":2889
 *     property true_residual:
 *         def __get__(self):
 *             return self.getTrueResidual()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTrueResidual(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTrueResidual); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2889, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2889, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2888
 * 
 *     property true_residual:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTrueResidual()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.true_residual.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2890
 *         def __get__(self):
 *             return self.getTrueResidual()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTrueResidual(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_13true_residual_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_13true_residual_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_13true_residual_2__set__(((struct PySlepcEPSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS_13true_residual_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/EPS.pyx":2891
 *             return self.getTrueResidual()
 *         def __set__(self, value):
 *             self.setTrueResidual(value)             # <<<<<<<<<<<<<<
 * 
 *     property purify:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTrueResidual); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":2890
 *         def __get__(self):
 *             return self.getTrueResidual()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTrueResidual(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.true_residual.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2894
 * 
 *     property purify:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getPurify()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_6purify_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_6purify_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_6purify___get__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_6purify___get__(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/EPS.pyx":2895
 *     property purify:
 *         def __get__(self):
 *             return self.getPurify()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setPurify(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getPurify); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2895, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2895, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2894
 * 
 *     property purify:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getPurify()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.purify.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2896
 *         def __get__(self):
 *             return self.getPurify()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setPurify(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_6purify_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_6purify_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_6purify_2__set__(((struct PySlepcEPSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS_6purify_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/EPS.pyx":2897
 *             return self.getPurify()
 *         def __set__(self, value):
 *             self.setPurify(value)             # <<<<<<<<<<<<<<
 * 
 *     property track_all:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setPurify); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2897, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2897, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":2896
 *         def __get__(self):
 *             return self.getPurify()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setPurify(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.purify.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2900
 * 
 *     property track_all:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTrackAll()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_9track_all_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_9track_all_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_9track_all___get__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_9track_all___get__(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/EPS.pyx":2901
 *     property track_all:
 *         def __get__(self):
 *             return self.getTrackAll()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTrackAll(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTrackAll); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2901, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2901, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2900
 * 
 *     property track_all:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTrackAll()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.track_all.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2902
 *         def __get__(self):
 *             return self.getTrackAll()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTrackAll(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_9track_all_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_9track_all_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_9track_all_2__set__(((struct PySlepcEPSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS_9track_all_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/EPS.pyx":2903
 *             return self.getTrackAll()
 *         def __set__(self, value):
 *             self.setTrackAll(value)             # <<<<<<<<<<<<<<
 * 
 *     property st:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTrackAll); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2903, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":2902
 *         def __get__(self):
 *             return self.getTrackAll()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTrackAll(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.track_all.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2906
 * 
 *     property st:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getST()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_2st_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_2st_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_2st___get__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_2st___get__(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/EPS.pyx":2907
 *     property st:
 *         def __get__(self):
 *             return self.getST()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setST(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getST); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2907, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2907, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2906
 * 
 *     property st:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getST()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.st.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2908
 *         def __get__(self):
 *             return self.getST()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setST(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_2st_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_2st_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_2st_2__set__(((struct PySlepcEPSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS_2st_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/EPS.pyx":2909
 *             return self.getST()
 *         def __set__(self, value):
 *             self.setST(value)             # <<<<<<<<<<<<<<
 * 
 *     property bv:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setST); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2909, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2909, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":2908
 *         def __get__(self):
 *             return self.getST()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setST(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.st.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2912
 * 
 *     property bv:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getBV()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_2bv_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_2bv_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_2bv___get__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_2bv___get__(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/EPS.pyx":2913
 *     property bv:
 *         def __get__(self):
 *             return self.getBV()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setBV(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getBV); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2913, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2913, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2912
 * 
 *     property bv:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getBV()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.bv.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2914
 *         def __get__(self):
 *             return self.getBV()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setBV(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_2bv_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_2bv_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_2bv_2__set__(((struct PySlepcEPSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS_2bv_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/EPS.pyx":2915
 *             return self.getBV()
 *         def __set__(self, value):
 *             self.setBV(value)             # <<<<<<<<<<<<<<
 * 
 *     property rg:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setBV); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2915, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2915, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":2914
 *         def __get__(self):
 *             return self.getBV()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setBV(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.bv.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2918
 * 
 *     property rg:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getRG()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_2rg_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_2rg_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_2rg___get__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_2rg___get__(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/EPS.pyx":2919
 *     property rg:
 *         def __get__(self):
 *             return self.getRG()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setRG(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getRG); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2919, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2919, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2918
 * 
 *     property rg:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getRG()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.rg.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2920
 *         def __get__(self):
 *             return self.getRG()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setRG(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_2rg_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_2rg_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_2rg_2__set__(((struct PySlepcEPSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS_2rg_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/EPS.pyx":2921
 *             return self.getRG()
 *         def __set__(self, value):
 *             self.setRG(value)             # <<<<<<<<<<<<<<
 * 
 *     property ds:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setRG); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":2920
 *         def __get__(self):
 *             return self.getRG()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setRG(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.rg.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2924
 * 
 *     property ds:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getDS()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_2ds_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3EPS_2ds_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_2ds___get__(((struct PySlepcEPSObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3EPS_2ds___get__(struct PySlepcEPSObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/EPS.pyx":2925
 *     property ds:
 *         def __get__(self):
 *             return self.getDS()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setDS(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getDS); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2925, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2925, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/EPS.pyx":2924
 * 
 *     property ds:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getDS()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.ds.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/EPS.pyx":2926
 *         def __get__(self):
 *             return self.getDS()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setDS(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_2ds_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3EPS_2ds_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3EPS_2ds_2__set__(((struct PySlepcEPSObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3EPS_2ds_2__set__(struct PySlepcEPSObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/EPS.pyx":2927
 *             return self.getDS()
 *         def __set__(self, value):
 *             self.setDS(value)             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setDS); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 2927, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 2927, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/EPS.pyx":2926
 *         def __get__(self):
 *             return self.getDS()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setDS(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.EPS.ds.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":140
 *     TRLanczosGBidiag = SVDTRLanczosGBidiag
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.svd
 *         self.svd = NULL
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD___cinit__(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3SVD___cinit__(struct PySlepcSVDObject *__pyx_v_self) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "SLEPc/SVD.pyx":141
 * 
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.svd             # <<<<<<<<<<<<<<
 *         self.svd = NULL
 * 
 */
  __pyx_v_self->__pyx_base.obj = ((PetscObject *)(&__pyx_v_self->svd));

  /* "SLEPc/SVD.pyx":142
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.svd
 *         self.svd = NULL             # <<<<<<<<<<<<<<
 * 
 *     def view(self, Viewer viewer=None):
 */
  __pyx_v_self->svd = NULL;

  /* "SLEPc/SVD.pyx":140
 *     TRLanczosGBidiag = SVDTRLanczosGBidiag
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.svd
 *         self.svd = NULL
 */

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":144
 *         self.svd = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the SVD data structure.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_2view[] = "SVD.view(self, Viewer viewer=None)\n\n        Prints the SVD data structure.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("view (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "view") < 0)) __PYX_ERR(18, 144, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("view", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 144, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(18, 144, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_2view(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_2view(struct PySlepcSVDObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("view", 0);

  /* "SLEPc/SVD.pyx":154
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDView(self.svd, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/SVD.pyx":155
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( SVDView(self.svd, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def destroy(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDView(__pyx_v_self->svd, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 155, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":144
 *         self.svd = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the SVD data structure.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":157
 *         CHKERR( SVDView(self.svd, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the SVD object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_4destroy[] = "SVD.destroy(self)\n\n        Destroys the SVD object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("destroy (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("destroy", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "destroy", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_4destroy(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_4destroy(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("destroy", 0);

  /* "SLEPc/SVD.pyx":161
 *         Destroys the SVD object.
 *         """
 *         CHKERR( SVDDestroy(&self.svd) )             # <<<<<<<<<<<<<<
 *         self.svd = NULL
 *         return self
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDDestroy((&__pyx_v_self->svd))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 161, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":162
 *         """
 *         CHKERR( SVDDestroy(&self.svd) )
 *         self.svd = NULL             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  __pyx_v_self->svd = NULL;

  /* "SLEPc/SVD.pyx":163
 *         CHKERR( SVDDestroy(&self.svd) )
 *         self.svd = NULL
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def reset(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":157
 *         CHKERR( SVDView(self.svd, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the SVD object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.destroy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":165
 *         return self
 * 
 *     def reset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Resets the SVD object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_7reset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_6reset[] = "SVD.reset(self)\n\n        Resets the SVD object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_7reset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("reset (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("reset", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "reset", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_6reset(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_6reset(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("reset", 0);

  /* "SLEPc/SVD.pyx":169
 *         Resets the SVD object.
 *         """
 *         CHKERR( SVDReset(self.svd) )             # <<<<<<<<<<<<<<
 * 
 *     def create(self, comm=None):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDReset(__pyx_v_self->svd)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 169, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":165
 *         return self
 * 
 *     def reset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Resets the SVD object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.reset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":171
 *         CHKERR( SVDReset(self.svd) )
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the SVD object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_9create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_8create[] = "SVD.create(self, comm=None)\n\n        Creates the SVD object.\n\n        Parameters\n        ----------\n        comm: Comm, optional\n              MPI communicator; if not provided, it defaults to all\n              processes.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_9create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comm = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comm,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comm);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create") < 0)) __PYX_ERR(18, 171, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_comm = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("create", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 171, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_8create(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_comm);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_8create(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_comm) {
  MPI_Comm __pyx_v_ccomm;
  SVD __pyx_v_newsvd;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  MPI_Comm __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("create", 0);

  /* "SLEPc/SVD.pyx":181
 *               processes.
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())             # <<<<<<<<<<<<<<
 *         cdef SlepcSVD newsvd = NULL
 *         CHKERR( SVDCreate(ccomm, &newsvd) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_def_Comm(__pyx_v_comm, __pyx_f_8slepc4py_5SLEPc_SLEPC_COMM_DEFAULT()); if (unlikely(PyErr_Occurred())) __PYX_ERR(18, 181, __pyx_L1_error)
  __pyx_v_ccomm = __pyx_t_1;

  /* "SLEPc/SVD.pyx":182
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcSVD newsvd = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( SVDCreate(ccomm, &newsvd) )
 *         SlepcCLEAR(self.obj); self.svd = newsvd
 */
  __pyx_v_newsvd = NULL;

  /* "SLEPc/SVD.pyx":183
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcSVD newsvd = NULL
 *         CHKERR( SVDCreate(ccomm, &newsvd) )             # <<<<<<<<<<<<<<
 *         SlepcCLEAR(self.obj); self.svd = newsvd
 *         return self
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDCreate(__pyx_v_ccomm, (&__pyx_v_newsvd))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 183, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":184
 *         cdef SlepcSVD newsvd = NULL
 *         CHKERR( SVDCreate(ccomm, &newsvd) )
 *         SlepcCLEAR(self.obj); self.svd = newsvd             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_SlepcCLEAR(__pyx_v_self->__pyx_base.obj));
  __pyx_v_self->svd = __pyx_v_newsvd;

  /* "SLEPc/SVD.pyx":185
 *         CHKERR( SVDCreate(ccomm, &newsvd) )
 *         SlepcCLEAR(self.obj); self.svd = newsvd
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def setType(self, svd_type):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":171
 *         CHKERR( SVDReset(self.svd) )
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the SVD object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":187
 *         return self
 * 
 *     def setType(self, svd_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the particular solver to be used in the SVD object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_11setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_10setType[] = "SVD.setType(self, svd_type)\n\n        Selects the particular solver to be used in the SVD object.\n\n        Parameters\n        ----------\n        svd_type: `SVD.Type` enumerate\n                  The solver to be used.\n\n        Notes\n        -----\n        See `SVD.Type` for available methods. The default is CROSS.\n        Normally, it is best to use `setFromOptions()` and then set\n        the SVD type from the options database rather than by using\n        this routine.  Using the options database provides the user\n        with maximum flexibility in evaluating the different available\n        methods.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_11setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_svd_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_svd_type,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_svd_type)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setType") < 0)) __PYX_ERR(18, 187, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_svd_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 187, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_10setType(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_svd_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_10setType(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_svd_type) {
  const char* __pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setType", 0);
  __Pyx_INCREF(__pyx_v_svd_type);

  /* "SLEPc/SVD.pyx":205
 *         methods.
 *         """
 *         cdef SlepcSVDType cval = NULL             # <<<<<<<<<<<<<<
 *         svd_type = str2bytes(svd_type, &cval)
 *         CHKERR( SVDSetType(self.svd, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/SVD.pyx":206
 *         """
 *         cdef SlepcSVDType cval = NULL
 *         svd_type = str2bytes(svd_type, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDSetType(self.svd, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_svd_type, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 206, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_svd_type, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":207
 *         cdef SlepcSVDType cval = NULL
 *         svd_type = str2bytes(svd_type, &cval)
 *         CHKERR( SVDSetType(self.svd, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getType(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetType(__pyx_v_self->svd, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 207, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":187
 *         return self
 * 
 *     def setType(self, svd_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the particular solver to be used in the SVD object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_svd_type);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":209
 *         CHKERR( SVDSetType(self.svd, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the SVD type of this object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_13getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_12getType[] = "SVD.getType(self)\n\n        Gets the SVD type of this object.\n\n        Returns\n        -------\n        type: `SVD.Type` enumerate\n              The solver currently being used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_13getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_12getType(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_12getType(struct PySlepcSVDObject *__pyx_v_self) {
  const char* __pyx_v_svd_type;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getType", 0);

  /* "SLEPc/SVD.pyx":218
 *               The solver currently being used.
 *         """
 *         cdef SlepcSVDType svd_type = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetType(self.svd, &svd_type) )
 *         return bytes2str(svd_type)
 */
  __pyx_v_svd_type = NULL;

  /* "SLEPc/SVD.pyx":219
 *         """
 *         cdef SlepcSVDType svd_type = NULL
 *         CHKERR( SVDGetType(self.svd, &svd_type) )             # <<<<<<<<<<<<<<
 *         return bytes2str(svd_type)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetType(__pyx_v_self->svd, (&__pyx_v_svd_type))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 219, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":220
 *         cdef SlepcSVDType svd_type = NULL
 *         CHKERR( SVDGetType(self.svd, &svd_type) )
 *         return bytes2str(svd_type)             # <<<<<<<<<<<<<<
 * 
 *     def getOptionsPrefix(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_svd_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":209
 *         CHKERR( SVDSetType(self.svd, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the SVD type of this object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":222
 *         return bytes2str(svd_type)
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all SVD options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_15getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_14getOptionsPrefix[] = "SVD.getOptionsPrefix(self)\n\n        Gets the prefix used for searching for all SVD options in the\n        database.\n\n        Returns\n        -------\n        prefix: string\n                The prefix string set for this SVD object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_15getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOptionsPrefix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOptionsPrefix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOptionsPrefix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_14getOptionsPrefix(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_14getOptionsPrefix(struct PySlepcSVDObject *__pyx_v_self) {
  const char *__pyx_v_prefix;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOptionsPrefix", 0);

  /* "SLEPc/SVD.pyx":232
 *                 The prefix string set for this SVD object.
 *         """
 *         cdef const_char *prefix = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetOptionsPrefix(self.svd, &prefix) )
 *         return bytes2str(prefix)
 */
  __pyx_v_prefix = NULL;

  /* "SLEPc/SVD.pyx":233
 *         """
 *         cdef const_char *prefix = NULL
 *         CHKERR( SVDGetOptionsPrefix(self.svd, &prefix) )             # <<<<<<<<<<<<<<
 *         return bytes2str(prefix)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetOptionsPrefix(__pyx_v_self->svd, (&__pyx_v_prefix))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 233, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":234
 *         cdef const_char *prefix = NULL
 *         CHKERR( SVDGetOptionsPrefix(self.svd, &prefix) )
 *         return bytes2str(prefix)             # <<<<<<<<<<<<<<
 * 
 *     def setOptionsPrefix(self, prefix):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_prefix); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":222
 *         return bytes2str(svd_type)
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all SVD options in the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":236
 *         return bytes2str(prefix)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all SVD options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_17setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_16setOptionsPrefix[] = "SVD.setOptionsPrefix(self, prefix)\n\n        Sets the prefix used for searching for all SVD options in the\n        database.\n\n        Parameters\n        ----------\n        prefix: string\n                The prefix string to prepend to all SVD option\n                requests.\n\n        Notes\n        -----\n        A hyphen (-) must NOT be given at the beginning of the prefix\n        name.  The first character of all runtime options is\n        AUTOMATICALLY the hyphen.\n\n        For example, to distinguish between the runtime options for\n        two different SVD contexts, one could call::\n\n            S1.setOptionsPrefix(\"svd1_\")\n            S2.setOptionsPrefix(\"svd2_\")\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_17setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOptionsPrefix") < 0)) __PYX_ERR(18, 236, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 236, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_16setOptionsPrefix(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_16setOptionsPrefix(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/SVD.pyx":259
 *             S2.setOptionsPrefix("svd2_")
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( SVDSetOptionsPrefix(self.svd, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/SVD.pyx":260
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDSetOptionsPrefix(self.svd, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 260, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":261
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( SVDSetOptionsPrefix(self.svd, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def appendOptionsPrefix(self, prefix):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetOptionsPrefix(__pyx_v_self->svd, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 261, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":236
 *         return bytes2str(prefix)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all SVD options in the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":263
 *         CHKERR( SVDSetOptionsPrefix(self.svd, cval) )
 * 
 *     def appendOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Appends to the prefix used for searching for all SVD options
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_19appendOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_18appendOptionsPrefix[] = "SVD.appendOptionsPrefix(self, prefix)\n\n        Appends to the prefix used for searching for all SVD options\n        in the database.\n\n        Parameters\n        ----------\n        prefix: string\n                The prefix string to prepend to all SVD option requests.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_19appendOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("appendOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "appendOptionsPrefix") < 0)) __PYX_ERR(18, 263, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("appendOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 263, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.appendOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_18appendOptionsPrefix(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_18appendOptionsPrefix(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("appendOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/SVD.pyx":273
 *                 The prefix string to prepend to all SVD option requests.
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( SVDAppendOptionsPrefix(self.svd, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/SVD.pyx":274
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDAppendOptionsPrefix(self.svd, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 274, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":275
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( SVDAppendOptionsPrefix(self.svd, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def setFromOptions(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDAppendOptionsPrefix(__pyx_v_self->svd, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 275, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":263
 *         CHKERR( SVDSetOptionsPrefix(self.svd, cval) )
 * 
 *     def appendOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Appends to the prefix used for searching for all SVD options
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.appendOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":277
 *         CHKERR( SVDAppendOptionsPrefix(self.svd, cval) )
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets SVD options from the options database. This routine must
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_21setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_20setFromOptions[] = "SVD.setFromOptions(self)\n\n        Sets SVD options from the options database. This routine must\n        be called before `setUp()` if the user is to be allowed to set\n        the solver type.\n\n        Notes\n        -----\n        To see all options, run your program with the ``-help``\n        option.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_21setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFromOptions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setFromOptions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setFromOptions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_20setFromOptions(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_20setFromOptions(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFromOptions", 0);

  /* "SLEPc/SVD.pyx":288
 *         option.
 *         """
 *         CHKERR( SVDSetFromOptions(self.svd) )             # <<<<<<<<<<<<<<
 * 
 *     def getProblemType(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetFromOptions(__pyx_v_self->svd)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 288, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":277
 *         CHKERR( SVDAppendOptionsPrefix(self.svd, cval) )
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets SVD options from the options database. This routine must
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setFromOptions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":290
 *         CHKERR( SVDSetFromOptions(self.svd) )
 * 
 *     def getProblemType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the problem type from the SVD object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_23getProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_22getProblemType[] = "SVD.getProblemType(self)\n\n        Gets the problem type from the SVD object.\n\n        Returns\n        -------\n        problem_type: `SVD.ProblemType` enumerate\n                      The problem type that was previously set.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_23getProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getProblemType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getProblemType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getProblemType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_22getProblemType(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_22getProblemType(struct PySlepcSVDObject *__pyx_v_self) {
  SVDProblemType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getProblemType", 0);

  /* "SLEPc/SVD.pyx":299
 *                       The problem type that was previously set.
 *         """
 *         cdef SlepcSVDProblemType val = SVD_STANDARD             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetProblemType(self.svd, &val) )
 *         return val
 */
  __pyx_v_val = SVD_STANDARD;

  /* "SLEPc/SVD.pyx":300
 *         """
 *         cdef SlepcSVDProblemType val = SVD_STANDARD
 *         CHKERR( SVDGetProblemType(self.svd, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetProblemType(__pyx_v_self->svd, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 300, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":301
 *         cdef SlepcSVDProblemType val = SVD_STANDARD
 *         CHKERR( SVDGetProblemType(self.svd, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setProblemType(self, problem_type):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_SVDProblemType(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 301, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":290
 *         CHKERR( SVDSetFromOptions(self.svd) )
 * 
 *     def getProblemType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the problem type from the SVD object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getProblemType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":303
 *         return val
 * 
 *     def setProblemType(self, problem_type):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the type of the singular value problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_25setProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_24setProblemType[] = "SVD.setProblemType(self, problem_type)\n\n        Specifies the type of the singular value problem.\n\n        Parameters\n        ----------\n        problem_type: `SVD.ProblemType` enumerate\n               The problem type to be set.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_25setProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_problem_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setProblemType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_problem_type,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_problem_type)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setProblemType") < 0)) __PYX_ERR(18, 303, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_problem_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setProblemType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 303, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setProblemType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_24setProblemType(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_problem_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_24setProblemType(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_problem_type) {
  SVDProblemType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  SVDProblemType __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setProblemType", 0);

  /* "SLEPc/SVD.pyx":312
 *                The problem type to be set.
 *         """
 *         cdef SlepcSVDProblemType val = problem_type             # <<<<<<<<<<<<<<
 *         CHKERR( SVDSetProblemType(self.svd, val) )
 * 
 */
  __pyx_t_1 = ((SVDProblemType)__Pyx_PyInt_As_SVDProblemType(__pyx_v_problem_type)); if (unlikely(PyErr_Occurred())) __PYX_ERR(18, 312, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/SVD.pyx":313
 *         """
 *         cdef SlepcSVDProblemType val = problem_type
 *         CHKERR( SVDSetProblemType(self.svd, val) )             # <<<<<<<<<<<<<<
 * 
 *     def isGeneralized(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetProblemType(__pyx_v_self->svd, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 313, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":303
 *         return val
 * 
 *     def setProblemType(self, problem_type):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the type of the singular value problem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setProblemType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":315
 *         CHKERR( SVDSetProblemType(self.svd, val) )
 * 
 *     def isGeneralized(self):             # <<<<<<<<<<<<<<
 *         """
 *         Tells whether the SVD object corresponds to a generalized
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_27isGeneralized(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_26isGeneralized[] = "SVD.isGeneralized(self)\n\n        Tells whether the SVD object corresponds to a generalized\n        singular value problem.\n\n        Returns\n        -------\n        flag: bool\n              True if two matrices were set with `setOperators()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_27isGeneralized(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("isGeneralized (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("isGeneralized", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isGeneralized", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_26isGeneralized(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_26isGeneralized(struct PySlepcSVDObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("isGeneralized", 0);

  /* "SLEPc/SVD.pyx":325
 *               True if two matrices were set with `setOperators()`.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( SVDIsGeneralized(self.svd, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/SVD.pyx":326
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDIsGeneralized(self.svd, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDIsGeneralized(__pyx_v_self->svd, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 326, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":327
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDIsGeneralized(self.svd, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def isHyperbolic(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 327, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":315
 *         CHKERR( SVDSetProblemType(self.svd, val) )
 * 
 *     def isGeneralized(self):             # <<<<<<<<<<<<<<
 *         """
 *         Tells whether the SVD object corresponds to a generalized
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.isGeneralized", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":329
 *         return toBool(tval)
 * 
 *     def isHyperbolic(self):             # <<<<<<<<<<<<<<
 *         """
 *         Tells whether the SVD object corresponds to a hyperbolic
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_29isHyperbolic(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_28isHyperbolic[] = "SVD.isHyperbolic(self)\n\n        Tells whether the SVD object corresponds to a hyperbolic\n        singular value problem.\n\n        Returns\n        -------\n        flag: bool\n              True if the problem was specified as hyperbolic.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_29isHyperbolic(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("isHyperbolic (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("isHyperbolic", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isHyperbolic", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_28isHyperbolic(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_28isHyperbolic(struct PySlepcSVDObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("isHyperbolic", 0);

  /* "SLEPc/SVD.pyx":339
 *               True if the problem was specified as hyperbolic.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( SVDIsHyperbolic(self.svd, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/SVD.pyx":340
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDIsHyperbolic(self.svd, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDIsHyperbolic(__pyx_v_self->svd, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 340, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":341
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDIsHyperbolic(self.svd, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 341, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":329
 *         return toBool(tval)
 * 
 *     def isHyperbolic(self):             # <<<<<<<<<<<<<<
 *         """
 *         Tells whether the SVD object corresponds to a hyperbolic
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.isHyperbolic", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":345
 *     #
 * 
 *     def getImplicitTranspose(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the mode used to handle the transpose of the matrix
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_31getImplicitTranspose(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_30getImplicitTranspose[] = "SVD.getImplicitTranspose(self)\n\n        Gets the mode used to handle the transpose of the matrix\n        associated with the singular value problem.\n\n        Returns\n        -------\n        impl: bool\n              How to handle the transpose (implicitly or not).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_31getImplicitTranspose(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getImplicitTranspose (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getImplicitTranspose", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getImplicitTranspose", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_30getImplicitTranspose(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_30getImplicitTranspose(struct PySlepcSVDObject *__pyx_v_self) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getImplicitTranspose", 0);

  /* "SLEPc/SVD.pyx":355
 *               How to handle the transpose (implicitly or not).
 *         """
 *         cdef PetscBool val = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetImplicitTranspose(self.svd, &val) )
 *         return toBool(val)
 */
  __pyx_v_val = PETSC_FALSE;

  /* "SLEPc/SVD.pyx":356
 *         """
 *         cdef PetscBool val = PETSC_FALSE
 *         CHKERR( SVDGetImplicitTranspose(self.svd, &val) )             # <<<<<<<<<<<<<<
 *         return toBool(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetImplicitTranspose(__pyx_v_self->svd, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 356, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":357
 *         cdef PetscBool val = PETSC_FALSE
 *         CHKERR( SVDGetImplicitTranspose(self.svd, &val) )
 *         return toBool(val)             # <<<<<<<<<<<<<<
 * 
 *     def setImplicitTranspose(self, mode):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 357, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":345
 *     #
 * 
 *     def getImplicitTranspose(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the mode used to handle the transpose of the matrix
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getImplicitTranspose", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":359
 *         return toBool(val)
 * 
 *     def setImplicitTranspose(self, mode):             # <<<<<<<<<<<<<<
 *         """
 *         Indicates how to handle the transpose of the matrix
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_33setImplicitTranspose(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_32setImplicitTranspose[] = "SVD.setImplicitTranspose(self, mode)\n\n        Indicates how to handle the transpose of the matrix\n        associated with the singular value problem.\n\n        Parameters\n        ----------\n        impl: bool\n              How to handle the transpose (implicitly or not).\n\n        Notes\n        -----\n        By default, the transpose of the matrix is explicitly built\n        (if the matrix has defined the MatTranspose operation).\n\n        If this flag is set to true, the solver does not build the\n        transpose, but handles it implicitly via MatMultTranspose().\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_33setImplicitTranspose(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_mode = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setImplicitTranspose (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_mode,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setImplicitTranspose") < 0)) __PYX_ERR(18, 359, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_mode = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setImplicitTranspose", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 359, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setImplicitTranspose", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_32setImplicitTranspose(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_mode);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_32setImplicitTranspose(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_mode) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setImplicitTranspose", 0);

  /* "SLEPc/SVD.pyx":377
 *         transpose, but handles it implicitly via MatMultTranspose().
 *         """
 *         cdef PetscBool val = asBool(mode)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDSetImplicitTranspose(self.svd, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_mode); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(18, 377, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/SVD.pyx":378
 *         """
 *         cdef PetscBool val = asBool(mode)
 *         CHKERR( SVDSetImplicitTranspose(self.svd, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getWhichSingularTriplets(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetImplicitTranspose(__pyx_v_self->svd, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 378, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":359
 *         return toBool(val)
 * 
 *     def setImplicitTranspose(self, mode):             # <<<<<<<<<<<<<<
 *         """
 *         Indicates how to handle the transpose of the matrix
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setImplicitTranspose", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":380
 *         CHKERR( SVDSetImplicitTranspose(self.svd, val) )
 * 
 *     def getWhichSingularTriplets(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns which singular triplets are to be sought.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_35getWhichSingularTriplets(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_34getWhichSingularTriplets[] = "SVD.getWhichSingularTriplets(self)\n\n        Returns which singular triplets are to be sought.\n\n        Returns\n        -------\n        which: `SVD.Which` enumerate\n               The singular values to be sought (either largest or\n               smallest).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_35getWhichSingularTriplets(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getWhichSingularTriplets (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getWhichSingularTriplets", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getWhichSingularTriplets", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_34getWhichSingularTriplets(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_34getWhichSingularTriplets(struct PySlepcSVDObject *__pyx_v_self) {
  SVDWhich __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getWhichSingularTriplets", 0);

  /* "SLEPc/SVD.pyx":390
 *                smallest).
 *         """
 *         cdef SlepcSVDWhich val = SVD_LARGEST             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetWhichSingularTriplets(self.svd, &val) )
 *         return val
 */
  __pyx_v_val = SVD_LARGEST;

  /* "SLEPc/SVD.pyx":391
 *         """
 *         cdef SlepcSVDWhich val = SVD_LARGEST
 *         CHKERR( SVDGetWhichSingularTriplets(self.svd, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetWhichSingularTriplets(__pyx_v_self->svd, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 391, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":392
 *         cdef SlepcSVDWhich val = SVD_LARGEST
 *         CHKERR( SVDGetWhichSingularTriplets(self.svd, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setWhichSingularTriplets(self, which):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_SVDWhich(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 392, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":380
 *         CHKERR( SVDSetImplicitTranspose(self.svd, val) )
 * 
 *     def getWhichSingularTriplets(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns which singular triplets are to be sought.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getWhichSingularTriplets", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":394
 *         return val
 * 
 *     def setWhichSingularTriplets(self, which):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies which singular triplets are to be sought.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_37setWhichSingularTriplets(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_36setWhichSingularTriplets[] = "SVD.setWhichSingularTriplets(self, which)\n\n        Specifies which singular triplets are to be sought.\n\n        Parameters\n        ----------\n        which: `SVD.Which` enumerate\n               The singular values to be sought (either largest or\n               smallest).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_37setWhichSingularTriplets(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_which = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setWhichSingularTriplets (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_which,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_which)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setWhichSingularTriplets") < 0)) __PYX_ERR(18, 394, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_which = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setWhichSingularTriplets", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 394, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setWhichSingularTriplets", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_36setWhichSingularTriplets(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_which);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_36setWhichSingularTriplets(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_which) {
  SVDWhich __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  SVDWhich __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setWhichSingularTriplets", 0);

  /* "SLEPc/SVD.pyx":404
 *                smallest).
 *         """
 *         cdef SlepcSVDWhich val = which             # <<<<<<<<<<<<<<
 *         CHKERR( SVDSetWhichSingularTriplets(self.svd, val) )
 * 
 */
  __pyx_t_1 = ((SVDWhich)__Pyx_PyInt_As_SVDWhich(__pyx_v_which)); if (unlikely(PyErr_Occurred())) __PYX_ERR(18, 404, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/SVD.pyx":405
 *         """
 *         cdef SlepcSVDWhich val = which
 *         CHKERR( SVDSetWhichSingularTriplets(self.svd, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getTolerances(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetWhichSingularTriplets(__pyx_v_self->svd, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 405, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":394
 *         return val
 * 
 *     def setWhichSingularTriplets(self, which):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies which singular triplets are to be sought.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setWhichSingularTriplets", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":407
 *         CHKERR( SVDSetWhichSingularTriplets(self.svd, val) )
 * 
 *     def getTolerances(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance and maximum iteration count used by the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_39getTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_38getTolerances[] = "SVD.getTolerances(self)\n\n        Gets the tolerance and maximum iteration count used by the\n        default SVD convergence tests.\n\n        Returns\n        -------\n        tol: float\n             The convergence tolerance.\n        max_it: int\n             The maximum number of iterations\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_39getTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTolerances (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTolerances", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTolerances", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_38getTolerances(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_38getTolerances(struct PySlepcSVDObject *__pyx_v_self) {
  PetscReal __pyx_v_rval;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTolerances", 0);

  /* "SLEPc/SVD.pyx":419
 *              The maximum number of iterations
 *         """
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = 0
 *         CHKERR( SVDGetTolerances(self.svd, &rval, &ival) )
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/SVD.pyx":420
 *         """
 *         cdef PetscReal rval = 0
 *         cdef PetscInt  ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetTolerances(self.svd, &rval, &ival) )
 *         return (toReal(rval), toInt(ival))
 */
  __pyx_v_ival = 0;

  /* "SLEPc/SVD.pyx":421
 *         cdef PetscReal rval = 0
 *         cdef PetscInt  ival = 0
 *         CHKERR( SVDGetTolerances(self.svd, &rval, &ival) )             # <<<<<<<<<<<<<<
 *         return (toReal(rval), toInt(ival))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetTolerances(__pyx_v_self->svd, (&__pyx_v_rval), (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 421, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":422
 *         cdef PetscInt  ival = 0
 *         CHKERR( SVDGetTolerances(self.svd, &rval, &ival) )
 *         return (toReal(rval), toInt(ival))             # <<<<<<<<<<<<<<
 * 
 *     def setTolerances(self, tol=None, max_it=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 422, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 422, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 422, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":407
 *         CHKERR( SVDSetWhichSingularTriplets(self.svd, val) )
 * 
 *     def getTolerances(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance and maximum iteration count used by the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":424
 *         return (toReal(rval), toInt(ival))
 * 
 *     def setTolerances(self, tol=None, max_it=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance and maximum iteration count used by the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_41setTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_40setTolerances[] = "SVD.setTolerances(self, tol=None, max_it=None)\n\n        Sets the tolerance and maximum iteration count used by the\n        default SVD convergence tests.\n\n        Parameters\n        ----------\n        tol: float, optional\n             The convergence tolerance.\n        max_it: int, optional\n             The maximum number of iterations\n\n        Notes\n        -----\n        Use `DECIDE` for `max_it` to assign a reasonably good value,\n        which is dependent on the solution method.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_41setTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_tol = 0;
  PyObject *__pyx_v_max_it = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTolerances (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_tol,&__pyx_n_s_max_it,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tol);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_it);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTolerances") < 0)) __PYX_ERR(18, 424, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_tol = values[0];
    __pyx_v_max_it = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTolerances", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 424, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_40setTolerances(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_tol, __pyx_v_max_it);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_40setTolerances(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_tol, PyObject *__pyx_v_max_it) {
  PetscReal __pyx_v_rval;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscReal __pyx_t_3;
  PetscInt __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTolerances", 0);

  /* "SLEPc/SVD.pyx":441
 *         which is dependent on the solution method.
 *         """
 *         cdef PetscReal rval = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol    is not None: rval = asReal(tol)
 */
  __pyx_v_rval = PETSC_DEFAULT;

  /* "SLEPc/SVD.pyx":442
 *         """
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if tol    is not None: rval = asReal(tol)
 *         if max_it is not None: ival = asInt(max_it)
 */
  __pyx_v_ival = PETSC_DEFAULT;

  /* "SLEPc/SVD.pyx":443
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol    is not None: rval = asReal(tol)             # <<<<<<<<<<<<<<
 *         if max_it is not None: ival = asInt(max_it)
 *         CHKERR( SVDSetTolerances(self.svd, rval, ival) )
 */
  __pyx_t_1 = (__pyx_v_tol != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_tol); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(18, 443, __pyx_L1_error)
    __pyx_v_rval = __pyx_t_3;
  }

  /* "SLEPc/SVD.pyx":444
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol    is not None: rval = asReal(tol)
 *         if max_it is not None: ival = asInt(max_it)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDSetTolerances(self.svd, rval, ival) )
 * 
 */
  __pyx_t_2 = (__pyx_v_max_it != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_max_it); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(18, 444, __pyx_L1_error)
    __pyx_v_ival = __pyx_t_4;
  }

  /* "SLEPc/SVD.pyx":445
 *         if tol    is not None: rval = asReal(tol)
 *         if max_it is not None: ival = asInt(max_it)
 *         CHKERR( SVDSetTolerances(self.svd, rval, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getConvergenceTest(self):
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetTolerances(__pyx_v_self->svd, __pyx_v_rval, __pyx_v_ival)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(18, 445, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":424
 *         return (toReal(rval), toInt(ival))
 * 
 *     def setTolerances(self, tol=None, max_it=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance and maximum iteration count used by the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":447
 *         CHKERR( SVDSetTolerances(self.svd, rval, ival) )
 * 
 *     def getConvergenceTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Return the method used to compute the error estimate
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_43getConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_42getConvergenceTest[] = "SVD.getConvergenceTest(self)\n\n        Return the method used to compute the error estimate\n        used in the convergence test.\n\n        Returns\n        -------\n        conv: SVD.Conv\n            The method used to compute the error estimate\n            used in the convergence test.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_43getConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getConvergenceTest (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getConvergenceTest", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConvergenceTest", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_42getConvergenceTest(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_42getConvergenceTest(struct PySlepcSVDObject *__pyx_v_self) {
  SVDConv __pyx_v_conv;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getConvergenceTest", 0);

  /* "SLEPc/SVD.pyx":458
 *             used in the convergence test.
 *         """
 *         cdef SlepcSVDConv conv = SVD_CONV_REL             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetConvergenceTest(self.svd, &conv) )
 *         return conv
 */
  __pyx_v_conv = SVD_CONV_REL;

  /* "SLEPc/SVD.pyx":459
 *         """
 *         cdef SlepcSVDConv conv = SVD_CONV_REL
 *         CHKERR( SVDGetConvergenceTest(self.svd, &conv) )             # <<<<<<<<<<<<<<
 *         return conv
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetConvergenceTest(__pyx_v_self->svd, (&__pyx_v_conv))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 459, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":460
 *         cdef SlepcSVDConv conv = SVD_CONV_REL
 *         CHKERR( SVDGetConvergenceTest(self.svd, &conv) )
 *         return conv             # <<<<<<<<<<<<<<
 * 
 *     def setConvergenceTest(self, conv):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_SVDConv(__pyx_v_conv); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 460, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":447
 *         CHKERR( SVDSetTolerances(self.svd, rval, ival) )
 * 
 *     def getConvergenceTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Return the method used to compute the error estimate
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getConvergenceTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":462
 *         return conv
 * 
 *     def setConvergenceTest(self, conv):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies how to compute the error estimate
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_45setConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_44setConvergenceTest[] = "SVD.setConvergenceTest(self, conv)\n\n        Specifies how to compute the error estimate\n        used in the convergence test.\n\n        Parameters\n        ----------\n        conv: SVD.Conv\n            The method used to compute the error estimate\n            used in the convergence test.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_45setConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_conv = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setConvergenceTest (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_conv,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_conv)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setConvergenceTest") < 0)) __PYX_ERR(18, 462, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_conv = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setConvergenceTest", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 462, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setConvergenceTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_44setConvergenceTest(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_conv);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_44setConvergenceTest(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_conv) {
  SVDConv __pyx_v_tconv;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  SVDConv __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setConvergenceTest", 0);

  /* "SLEPc/SVD.pyx":473
 *             used in the convergence test.
 *         """
 *         cdef SlepcSVDConv tconv = conv             # <<<<<<<<<<<<<<
 *         CHKERR( SVDSetConvergenceTest(self.svd, tconv) )
 * 
 */
  __pyx_t_1 = ((SVDConv)__Pyx_PyInt_As_SVDConv(__pyx_v_conv)); if (unlikely(PyErr_Occurred())) __PYX_ERR(18, 473, __pyx_L1_error)
  __pyx_v_tconv = __pyx_t_1;

  /* "SLEPc/SVD.pyx":474
 *         """
 *         cdef SlepcSVDConv tconv = conv
 *         CHKERR( SVDSetConvergenceTest(self.svd, tconv) )             # <<<<<<<<<<<<<<
 * 
 *     def getTrackAll(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetConvergenceTest(__pyx_v_self->svd, __pyx_v_tconv)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 474, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":462
 *         return conv
 * 
 *     def setConvergenceTest(self, conv):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies how to compute the error estimate
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setConvergenceTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":476
 *         CHKERR( SVDSetConvergenceTest(self.svd, tconv) )
 * 
 *     def getTrackAll(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether all residual norms must be
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_47getTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_46getTrackAll[] = "SVD.getTrackAll(self)\n\n        Returns the flag indicating whether all residual norms must be\n        computed or not.\n\n        Returns\n        -------\n        trackall: bool\n            Whether the solver compute all residuals or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_47getTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTrackAll (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTrackAll", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTrackAll", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_46getTrackAll(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_46getTrackAll(struct PySlepcSVDObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTrackAll", 0);

  /* "SLEPc/SVD.pyx":486
 *             Whether the solver compute all residuals or not.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetTrackAll(self.svd, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/SVD.pyx":487
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDGetTrackAll(self.svd, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetTrackAll(__pyx_v_self->svd, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 487, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":488
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDGetTrackAll(self.svd, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setTrackAll(self, trackall):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 488, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":476
 *         CHKERR( SVDSetConvergenceTest(self.svd, tconv) )
 * 
 *     def getTrackAll(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether all residual norms must be
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getTrackAll", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":490
 *         return toBool(tval)
 * 
 *     def setTrackAll(self, trackall):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies if the solver must compute the residual of all
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_49setTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_48setTrackAll[] = "SVD.setTrackAll(self, trackall)\n\n        Specifies if the solver must compute the residual of all\n        approximate singular triplets or not.\n\n        Parameters\n        ----------\n        trackall: bool\n            Whether compute all residuals or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_49setTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_trackall = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTrackAll (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_trackall,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_trackall)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTrackAll") < 0)) __PYX_ERR(18, 490, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_trackall = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTrackAll", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 490, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTrackAll", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_48setTrackAll(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_trackall);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_48setTrackAll(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_trackall) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTrackAll", 0);

  /* "SLEPc/SVD.pyx":500
 *             Whether compute all residuals or not.
 *         """
 *         cdef PetscBool tval = asBool(trackall)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDSetTrackAll(self.svd, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_trackall); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(18, 500, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/SVD.pyx":501
 *         """
 *         cdef PetscBool tval = asBool(trackall)
 *         CHKERR( SVDSetTrackAll(self.svd, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getDimensions(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetTrackAll(__pyx_v_self->svd, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 501, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":490
 *         return toBool(tval)
 * 
 *     def setTrackAll(self, trackall):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies if the solver must compute the residual of all
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTrackAll", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":503
 *         CHKERR( SVDSetTrackAll(self.svd, tval) )
 * 
 *     def getDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of singular values to compute and the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_51getDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_50getDimensions[] = "SVD.getDimensions(self)\n\n        Gets the number of singular values to compute and the\n        dimension of the subspace.\n\n        Returns\n        -------\n        nsv: int\n             Number of singular values to compute.\n        ncv: int\n             Maximum dimension of the subspace to be used by the\n             solver.\n        mpd: int\n             Maximum dimension allowed for the projected problem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_51getDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDimensions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getDimensions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDimensions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_50getDimensions(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_50getDimensions(struct PySlepcSVDObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getDimensions", 0);

  /* "SLEPc/SVD.pyx":518
 *              Maximum dimension allowed for the projected problem.
 *         """
 *         cdef PetscInt ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/SVD.pyx":519
 *         """
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival3 = 0
 *         CHKERR( SVDGetDimensions(self.svd, &ival1, &ival2, &ival3) )
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/SVD.pyx":520
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetDimensions(self.svd, &ival1, &ival2, &ival3) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 */
  __pyx_v_ival3 = 0;

  /* "SLEPc/SVD.pyx":521
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 *         CHKERR( SVDGetDimensions(self.svd, &ival1, &ival2, &ival3) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetDimensions(__pyx_v_self->svd, (&__pyx_v_ival1), (&__pyx_v_ival2), (&__pyx_v_ival3))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 521, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":522
 *         cdef PetscInt ival3 = 0
 *         CHKERR( SVDGetDimensions(self.svd, &ival1, &ival2, &ival3) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))             # <<<<<<<<<<<<<<
 * 
 *     def setDimensions(self, nsv=None, ncv=None, mpd=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 522, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 522, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival3); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 522, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 522, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":503
 *         CHKERR( SVDSetTrackAll(self.svd, tval) )
 * 
 *     def getDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of singular values to compute and the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":524
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 *     def setDimensions(self, nsv=None, ncv=None, mpd=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of singular values to compute and the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_53setDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_52setDimensions[] = "SVD.setDimensions(self, nsv=None, ncv=None, mpd=None)\n\n        Sets the number of singular values to compute and the\n        dimension of the subspace.\n\n        Parameters\n        ----------\n        nsv: int, optional\n             Number of singular values to compute.\n        ncv: int, optional\n             Maximum dimension of the subspace to be used by the\n             solver.\n        mpd: int, optional\n             Maximum dimension allowed for the projected problem.\n\n        Notes\n        -----\n        Use `DECIDE` for `ncv` and `mpd` to assign a reasonably good\n        value, which is dependent on the solution method.\n\n        The parameters `ncv` and `mpd` are intimately related, so that\n        the user is advised to set one of them at most. Normal usage\n        is the following:\n\n         - In cases where `nsv` is small, the user sets `ncv`\n           (a reasonable default is 2 * `nsv`).\n         - In cases where `nsv` is large, the user sets `mpd`.\n\n        The value of `ncv` should always be between `nsv` and (`nsv` +\n        `mpd`), typically `ncv` = `nsv` + `mpd`. If `nsv` is not too\n        large, `mpd` = `nsv` is a reasonable choice, otherwise a\n        smaller value should be used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_53setDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nsv = 0;
  PyObject *__pyx_v_ncv = 0;
  PyObject *__pyx_v_mpd = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setDimensions (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nsv,&__pyx_n_s_ncv,&__pyx_n_s_mpd,0};
    PyObject* values[3] = {0,0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nsv);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ncv);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mpd);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setDimensions") < 0)) __PYX_ERR(18, 524, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_nsv = values[0];
    __pyx_v_ncv = values[1];
    __pyx_v_mpd = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setDimensions", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 524, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_52setDimensions(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_nsv, __pyx_v_ncv, __pyx_v_mpd);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_52setDimensions(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_nsv, PyObject *__pyx_v_ncv, PyObject *__pyx_v_mpd) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setDimensions", 0);

  /* "SLEPc/SVD.pyx":557
 *         smaller value should be used.
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/SVD.pyx":558
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nsv is not None: ival1 = asInt(nsv)
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/SVD.pyx":559
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if nsv is not None: ival1 = asInt(nsv)
 *         if ncv is not None: ival2 = asInt(ncv)
 */
  __pyx_v_ival3 = PETSC_DEFAULT;

  /* "SLEPc/SVD.pyx":560
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nsv is not None: ival1 = asInt(nsv)             # <<<<<<<<<<<<<<
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)
 */
  __pyx_t_1 = (__pyx_v_nsv != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_nsv); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(18, 560, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_3;
  }

  /* "SLEPc/SVD.pyx":561
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nsv is not None: ival1 = asInt(nsv)
 *         if ncv is not None: ival2 = asInt(ncv)             # <<<<<<<<<<<<<<
 *         if mpd is not None: ival3 = asInt(mpd)
 *         CHKERR( SVDSetDimensions(self.svd, ival1, ival2, ival3) )
 */
  __pyx_t_2 = (__pyx_v_ncv != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_ncv); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(18, 561, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_3;
  }

  /* "SLEPc/SVD.pyx":562
 *         if nsv is not None: ival1 = asInt(nsv)
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDSetDimensions(self.svd, ival1, ival2, ival3) )
 * 
 */
  __pyx_t_1 = (__pyx_v_mpd != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_mpd); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(18, 562, __pyx_L1_error)
    __pyx_v_ival3 = __pyx_t_3;
  }

  /* "SLEPc/SVD.pyx":563
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)
 *         CHKERR( SVDSetDimensions(self.svd, ival1, ival2, ival3) )             # <<<<<<<<<<<<<<
 * 
 *     def getBV(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetDimensions(__pyx_v_self->svd, __pyx_v_ival1, __pyx_v_ival2, __pyx_v_ival3)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(18, 563, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":524
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 *     def setDimensions(self, nsv=None, ncv=None, mpd=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of singular values to compute and the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":565
 *         CHKERR( SVDSetDimensions(self.svd, ival1, ival2, ival3) )
 * 
 *     def getBV(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the basis vectors objects associated to the SVD object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_55getBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_54getBV[] = "SVD.getBV(self)\n\n        Obtain the basis vectors objects associated to the SVD object.\n\n        Returns\n        -------\n        V: BV\n            The basis vectors context for right singular vectors.\n        U: BV\n            The basis vectors context for left singular vectors.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_55getBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getBV (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getBV", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBV", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_54getBV(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_54getBV(struct PySlepcSVDObject *__pyx_v_self) {
  struct PySlepcBVObject *__pyx_v_V = 0;
  struct PySlepcBVObject *__pyx_v_U = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getBV", 0);

  /* "SLEPc/SVD.pyx":576
 *             The basis vectors context for left singular vectors.
 *         """
 *         cdef BV V = BV()             # <<<<<<<<<<<<<<
 *         cdef BV U = BV()
 *         CHKERR( SVDGetBV(self.svd, &V.bv, &U.bv) )
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 576, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_V = ((struct PySlepcBVObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":577
 *         """
 *         cdef BV V = BV()
 *         cdef BV U = BV()             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetBV(self.svd, &V.bv, &U.bv) )
 *         PetscINCREF(V.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 577, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_U = ((struct PySlepcBVObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":578
 *         cdef BV V = BV()
 *         cdef BV U = BV()
 *         CHKERR( SVDGetBV(self.svd, &V.bv, &U.bv) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(V.obj)
 *         PetscINCREF(U.obj)
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetBV(__pyx_v_self->svd, (&__pyx_v_V->bv), (&__pyx_v_U->bv))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 578, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":579
 *         cdef BV U = BV()
 *         CHKERR( SVDGetBV(self.svd, &V.bv, &U.bv) )
 *         PetscINCREF(V.obj)             # <<<<<<<<<<<<<<
 *         PetscINCREF(U.obj)
 *         return (V,U)
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_V->__pyx_base.obj));

  /* "SLEPc/SVD.pyx":580
 *         CHKERR( SVDGetBV(self.svd, &V.bv, &U.bv) )
 *         PetscINCREF(V.obj)
 *         PetscINCREF(U.obj)             # <<<<<<<<<<<<<<
 *         return (V,U)
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_U->__pyx_base.obj));

  /* "SLEPc/SVD.pyx":581
 *         PetscINCREF(V.obj)
 *         PetscINCREF(U.obj)
 *         return (V,U)             # <<<<<<<<<<<<<<
 * 
 *     def setBV(self, BV V,BV U=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 581, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(((PyObject *)__pyx_v_V));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_V));
  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_V));
  __Pyx_INCREF(((PyObject *)__pyx_v_U));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_U));
  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_U));
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":565
 *         CHKERR( SVDSetDimensions(self.svd, ival1, ival2, ival3) )
 * 
 *     def getBV(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the basis vectors objects associated to the SVD object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_V);
  __Pyx_XDECREF((PyObject *)__pyx_v_U);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":583
 *         return (V,U)
 * 
 *     def setBV(self, BV V,BV U=None):             # <<<<<<<<<<<<<<
 *         """
 *         Associates basis vectors objects to the SVD solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_57setBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_56setBV[] = "SVD.setBV(self, BV V, BV U=None)\n\n        Associates basis vectors objects to the SVD solver.\n\n        Parameters\n        ----------\n        V: BV\n            The basis vectors context for right singular vectors.\n        U: BV\n            The basis vectors context for left singular vectors.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_57setBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcBVObject *__pyx_v_V = 0;
  struct PySlepcBVObject *__pyx_v_U = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setBV (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_V,&__pyx_n_s_U,0};
    PyObject* values[2] = {0,0};
    values[1] = (PyObject *)((struct PySlepcBVObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_V)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_U);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setBV") < 0)) __PYX_ERR(18, 583, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_V = ((struct PySlepcBVObject *)values[0]);
    __pyx_v_U = ((struct PySlepcBVObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setBV", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 583, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_V), __pyx_ptype_8slepc4py_5SLEPc_BV, 0, "V", 0))) __PYX_ERR(18, 583, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_U), __pyx_ptype_8slepc4py_5SLEPc_BV, 1, "U", 0))) __PYX_ERR(18, 583, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_56setBV(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_V, __pyx_v_U);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_56setBV(struct PySlepcSVDObject *__pyx_v_self, struct PySlepcBVObject *__pyx_v_V, struct PySlepcBVObject *__pyx_v_U) {
  BV __pyx_v_VBV;
  BV __pyx_v_UBV;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  BV __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setBV", 0);

  /* "SLEPc/SVD.pyx":594
 *             The basis vectors context for left singular vectors.
 *         """
 *         cdef SlepcBV VBV = V.bv             # <<<<<<<<<<<<<<
 *         cdef SlepcBV UBV = U.bv if U is not None else <SlepcBV>NULL
 *         CHKERR( SVDSetBV(self.svd, VBV, UBV) )
 */
  __pyx_t_1 = __pyx_v_V->bv;
  __pyx_v_VBV = __pyx_t_1;

  /* "SLEPc/SVD.pyx":595
 *         """
 *         cdef SlepcBV VBV = V.bv
 *         cdef SlepcBV UBV = U.bv if U is not None else <SlepcBV>NULL             # <<<<<<<<<<<<<<
 *         CHKERR( SVDSetBV(self.svd, VBV, UBV) )
 * 
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_U) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_U->bv;
  } else {
    __pyx_t_1 = ((BV)NULL);
  }
  __pyx_v_UBV = __pyx_t_1;

  /* "SLEPc/SVD.pyx":596
 *         cdef SlepcBV VBV = V.bv
 *         cdef SlepcBV UBV = U.bv if U is not None else <SlepcBV>NULL
 *         CHKERR( SVDSetBV(self.svd, VBV, UBV) )             # <<<<<<<<<<<<<<
 * 
 *     def getDS(self):
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetBV(__pyx_v_self->svd, __pyx_v_VBV, __pyx_v_UBV)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(18, 596, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":583
 *         return (V,U)
 * 
 *     def setBV(self, BV V,BV U=None):             # <<<<<<<<<<<<<<
 *         """
 *         Associates basis vectors objects to the SVD solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":598
 *         CHKERR( SVDSetBV(self.svd, VBV, UBV) )
 * 
 *     def getDS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the direct solver associated to the singular value solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_59getDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_58getDS[] = "SVD.getDS(self)\n\n        Obtain the direct solver associated to the singular value solver.\n\n        Returns\n        -------\n        ds: DS\n            The direct solver context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_59getDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDS (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getDS", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDS", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_58getDS(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_58getDS(struct PySlepcSVDObject *__pyx_v_self) {
  struct PySlepcDSObject *__pyx_v_ds = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getDS", 0);

  /* "SLEPc/SVD.pyx":607
 *             The direct solver context.
 *         """
 *         cdef DS ds = DS()             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetDS(self.svd, &ds.ds) )
 *         PetscINCREF(ds.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_DS)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 607, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ds = ((struct PySlepcDSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":608
 *         """
 *         cdef DS ds = DS()
 *         CHKERR( SVDGetDS(self.svd, &ds.ds) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(ds.obj)
 *         return ds
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetDS(__pyx_v_self->svd, (&__pyx_v_ds->ds))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 608, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":609
 *         cdef DS ds = DS()
 *         CHKERR( SVDGetDS(self.svd, &ds.ds) )
 *         PetscINCREF(ds.obj)             # <<<<<<<<<<<<<<
 *         return ds
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ds->__pyx_base.obj));

  /* "SLEPc/SVD.pyx":610
 *         CHKERR( SVDGetDS(self.svd, &ds.ds) )
 *         PetscINCREF(ds.obj)
 *         return ds             # <<<<<<<<<<<<<<
 * 
 *     def setDS(self, DS ds):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ds));
  __pyx_r = ((PyObject *)__pyx_v_ds);
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":598
 *         CHKERR( SVDSetBV(self.svd, VBV, UBV) )
 * 
 *     def getDS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the direct solver associated to the singular value solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ds);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":612
 *         return ds
 * 
 *     def setDS(self, DS ds):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a direct solver object to the singular value solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_61setDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_60setDS[] = "SVD.setDS(self, DS ds)\n\n        Associates a direct solver object to the singular value solver.\n\n        Parameters\n        ----------\n        ds: DS\n            The direct solver context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_61setDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcDSObject *__pyx_v_ds = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setDS (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ds,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ds)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setDS") < 0)) __PYX_ERR(18, 612, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_ds = ((struct PySlepcDSObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setDS", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 612, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ds), __pyx_ptype_8slepc4py_5SLEPc_DS, 0, "ds", 0))) __PYX_ERR(18, 612, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_60setDS(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_ds);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_60setDS(struct PySlepcSVDObject *__pyx_v_self, struct PySlepcDSObject *__pyx_v_ds) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setDS", 0);

  /* "SLEPc/SVD.pyx":621
 *             The direct solver context.
 *         """
 *         CHKERR( SVDSetDS(self.svd, ds.ds) )             # <<<<<<<<<<<<<<
 * 
 *     def getOperators(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetDS(__pyx_v_self->svd, __pyx_v_ds->ds)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 621, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":612
 *         return ds
 * 
 *     def setDS(self, DS ds):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a direct solver object to the singular value solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":623
 *         CHKERR( SVDSetDS(self.svd, ds.ds) )
 * 
 *     def getOperators(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the matrices associated with the singular value problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_63getOperators(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_62getOperators[] = "SVD.getOperators(self)\n\n        Gets the matrices associated with the singular value problem.\n\n        Returns\n        -------\n        A: Mat\n           The matrix associated with the singular value problem.\n        B: Mat\n           The second matrix in the case of GSVD.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_63getOperators(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOperators (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOperators", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOperators", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_62getOperators(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_62getOperators(struct PySlepcSVDObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  struct PyPetscMatObject *__pyx_v_B = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOperators", 0);

  /* "SLEPc/SVD.pyx":634
 *            The second matrix in the case of GSVD.
 *         """
 *         cdef Mat A = Mat()             # <<<<<<<<<<<<<<
 *         cdef Mat B = Mat()
 *         CHKERR( SVDGetOperators(self.svd, &A.mat, &B.mat) )
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 634, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_A = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":635
 *         """
 *         cdef Mat A = Mat()
 *         cdef Mat B = Mat()             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetOperators(self.svd, &A.mat, &B.mat) )
 *         PetscINCREF(A.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 635, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_B = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":636
 *         cdef Mat A = Mat()
 *         cdef Mat B = Mat()
 *         CHKERR( SVDGetOperators(self.svd, &A.mat, &B.mat) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(A.obj)
 *         PetscINCREF(B.obj)
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetOperators(__pyx_v_self->svd, (&__pyx_v_A->mat), (&__pyx_v_B->mat))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 636, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":637
 *         cdef Mat B = Mat()
 *         CHKERR( SVDGetOperators(self.svd, &A.mat, &B.mat) )
 *         PetscINCREF(A.obj)             # <<<<<<<<<<<<<<
 *         PetscINCREF(B.obj)
 *         return (A, B)
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_A->__pyx_base.obj));

  /* "SLEPc/SVD.pyx":638
 *         CHKERR( SVDGetOperators(self.svd, &A.mat, &B.mat) )
 *         PetscINCREF(A.obj)
 *         PetscINCREF(B.obj)             # <<<<<<<<<<<<<<
 *         return (A, B)
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_B->__pyx_base.obj));

  /* "SLEPc/SVD.pyx":639
 *         PetscINCREF(A.obj)
 *         PetscINCREF(B.obj)
 *         return (A, B)             # <<<<<<<<<<<<<<
 * 
 *     def setOperators(self, Mat A, Mat B=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 639, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(((PyObject *)__pyx_v_A));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_A));
  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_A));
  __Pyx_INCREF(((PyObject *)__pyx_v_B));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_B));
  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_B));
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":623
 *         CHKERR( SVDSetDS(self.svd, ds.ds) )
 * 
 *     def getOperators(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the matrices associated with the singular value problem.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getOperators", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_A);
  __Pyx_XDECREF((PyObject *)__pyx_v_B);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":641
 *         return (A, B)
 * 
 *     def setOperators(self, Mat A, Mat B=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the matrices associated with the singular value problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_65setOperators(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_64setOperators[] = "SVD.setOperators(self, Mat A, Mat B=None)\n\n        Sets the matrices associated with the singular value problem.\n\n        Parameters\n        ----------\n        A: Mat\n           The matrix associated with the singular value problem.\n        B: Mat, optional\n           The second matrix in the case of GSVD; if not provided,\n           a usual SVD is assumed.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_65setOperators(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  struct PyPetscMatObject *__pyx_v_B = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOperators (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_A,&__pyx_n_s_B,0};
    PyObject* values[2] = {0,0};
    values[1] = (PyObject *)((struct PyPetscMatObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_A)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_B);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOperators") < 0)) __PYX_ERR(18, 641, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_A = ((struct PyPetscMatObject *)values[0]);
    __pyx_v_B = ((struct PyPetscMatObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOperators", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 641, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setOperators", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_A), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "A", 0))) __PYX_ERR(18, 641, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_B), __pyx_ptype_8petsc4py_5PETSc_Mat, 1, "B", 0))) __PYX_ERR(18, 641, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_64setOperators(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_A, __pyx_v_B);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_64setOperators(struct PySlepcSVDObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A, struct PyPetscMatObject *__pyx_v_B) {
  Mat __pyx_v_Bmat;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Mat __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOperators", 0);

  /* "SLEPc/SVD.pyx":653
 *            a usual SVD is assumed.
 *         """
 *         cdef PetscMat Bmat = B.mat if B is not None else <PetscMat>NULL             # <<<<<<<<<<<<<<
 *         CHKERR( SVDSetOperators(self.svd, A.mat, Bmat) )
 * 
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_B) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_B->mat;
  } else {
    __pyx_t_1 = ((Mat)NULL);
  }
  __pyx_v_Bmat = __pyx_t_1;

  /* "SLEPc/SVD.pyx":654
 *         """
 *         cdef PetscMat Bmat = B.mat if B is not None else <PetscMat>NULL
 *         CHKERR( SVDSetOperators(self.svd, A.mat, Bmat) )             # <<<<<<<<<<<<<<
 * 
 *     def getSignature(self):
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetOperators(__pyx_v_self->svd, __pyx_v_A->mat, __pyx_v_Bmat)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(18, 654, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":641
 *         return (A, B)
 * 
 *     def setOperators(self, Mat A, Mat B=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the matrices associated with the singular value problem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setOperators", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":656
 *         CHKERR( SVDSetOperators(self.svd, A.mat, Bmat) )
 * 
 *     def getSignature(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the signature matrix defining a hyperbolic singular value problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_67getSignature(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_66getSignature[] = "SVD.getSignature(self)\n\n        Gets the signature matrix defining a hyperbolic singular value problem.\n\n        Returns\n        -------\n        omega: Vec\n           A vector containing the diagonal elements of the signature matrix.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_67getSignature(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSignature (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSignature", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSignature", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_66getSignature(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_66getSignature(struct PySlepcSVDObject *__pyx_v_self) {
  struct PyPetscVecObject *__pyx_v_omega = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSignature", 0);

  /* "SLEPc/SVD.pyx":665
 *            A vector containing the diagonal elements of the signature matrix.
 *         """
 *         cdef Vec omega = Vec()             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetSignature(self.svd, &omega.vec) )
 *         if (omega.vec == NULL):
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Vec)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 665, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_omega = ((struct PyPetscVecObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":666
 *         """
 *         cdef Vec omega = Vec()
 *         CHKERR( SVDGetSignature(self.svd, &omega.vec) )             # <<<<<<<<<<<<<<
 *         if (omega.vec == NULL):
 *             return None
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetSignature(__pyx_v_self->svd, (&__pyx_v_omega->vec))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 666, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":667
 *         cdef Vec omega = Vec()
 *         CHKERR( SVDGetSignature(self.svd, &omega.vec) )
 *         if (omega.vec == NULL):             # <<<<<<<<<<<<<<
 *             return None
 *         else:
 */
  __pyx_t_3 = ((__pyx_v_omega->vec == NULL) != 0);
  if (__pyx_t_3) {

    /* "SLEPc/SVD.pyx":668
 *         CHKERR( SVDGetSignature(self.svd, &omega.vec) )
 *         if (omega.vec == NULL):
 *             return None             # <<<<<<<<<<<<<<
 *         else:
 *             PetscINCREF(omega.obj)
 */
    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;

    /* "SLEPc/SVD.pyx":667
 *         cdef Vec omega = Vec()
 *         CHKERR( SVDGetSignature(self.svd, &omega.vec) )
 *         if (omega.vec == NULL):             # <<<<<<<<<<<<<<
 *             return None
 *         else:
 */
  }

  /* "SLEPc/SVD.pyx":670
 *             return None
 *         else:
 *             PetscINCREF(omega.obj)             # <<<<<<<<<<<<<<
 *             return omega
 * 
 */
  /*else*/ {
    (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_omega->__pyx_base.obj));

    /* "SLEPc/SVD.pyx":671
 *         else:
 *             PetscINCREF(omega.obj)
 *             return omega             # <<<<<<<<<<<<<<
 * 
 *     def setSignature(self, Vec omega=None):
 */
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(((PyObject *)__pyx_v_omega));
    __pyx_r = ((PyObject *)__pyx_v_omega);
    goto __pyx_L0;
  }

  /* "SLEPc/SVD.pyx":656
 *         CHKERR( SVDSetOperators(self.svd, A.mat, Bmat) )
 * 
 *     def getSignature(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the signature matrix defining a hyperbolic singular value problem.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getSignature", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_omega);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":673
 *             return omega
 * 
 *     def setSignature(self, Vec omega=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the signature matrix defining a hyperbolic singular value problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_69setSignature(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_68setSignature[] = "SVD.setSignature(self, Vec omega=None)\n\n        Sets the signature matrix defining a hyperbolic singular value problem.\n\n        Parameters\n        ----------\n        omega: Vec, optional\n           A vector containing the diagonal elements of the signature matrix.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_69setSignature(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscVecObject *__pyx_v_omega = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSignature (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_omega,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_omega);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSignature") < 0)) __PYX_ERR(18, 673, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_omega = ((struct PyPetscVecObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSignature", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 673, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setSignature", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_omega), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "omega", 0))) __PYX_ERR(18, 673, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_68setSignature(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_omega);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_68setSignature(struct PySlepcSVDObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_omega) {
  Vec __pyx_v_Ovec;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Vec __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSignature", 0);

  /* "SLEPc/SVD.pyx":682
 *            A vector containing the diagonal elements of the signature matrix.
 *         """
 *         cdef PetscVec Ovec = omega.vec if omega is not None else <PetscVec>NULL             # <<<<<<<<<<<<<<
 *         CHKERR( SVDSetSignature(self.svd, Ovec) )
 * 
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_omega) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_omega->vec;
  } else {
    __pyx_t_1 = ((Vec)NULL);
  }
  __pyx_v_Ovec = __pyx_t_1;

  /* "SLEPc/SVD.pyx":683
 *         """
 *         cdef PetscVec Ovec = omega.vec if omega is not None else <PetscVec>NULL
 *         CHKERR( SVDSetSignature(self.svd, Ovec) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetSignature(__pyx_v_self->svd, __pyx_v_Ovec)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(18, 683, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":673
 *             return omega
 * 
 *     def setSignature(self, Vec omega=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the signature matrix defining a hyperbolic singular value problem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setSignature", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":687
 *     #
 * 
 *     def setInitialSpaces(self, spaceright=None, spaceleft=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the initial spaces from which the SVD solver starts to
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_71setInitialSpaces(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_70setInitialSpaces[] = "SVD.setInitialSpaces(self, spaceright=None, spaceleft=None)\n\n        Sets the initial spaces from which the SVD solver starts to\n        iterate.\n\n        Parameters\n        ----------\n        spaceright: sequence of Vec\n           The right initial space.\n        spaceleft: sequence of Vec\n           The left initial space.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_71setInitialSpaces(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_spaceright = 0;
  PyObject *__pyx_v_spaceleft = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setInitialSpaces (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_spaceright,&__pyx_n_s_spaceleft,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_spaceright);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_spaceleft);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setInitialSpaces") < 0)) __PYX_ERR(18, 687, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_spaceright = values[0];
    __pyx_v_spaceleft = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setInitialSpaces", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 687, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setInitialSpaces", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_70setInitialSpaces(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_spaceright, __pyx_v_spaceleft);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_70setInitialSpaces(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_spaceright, PyObject *__pyx_v_spaceleft) {
  Py_ssize_t __pyx_v_i;
  Vec *__pyx_v_isr;
  Py_ssize_t __pyx_v_nr;
  CYTHON_UNUSED PyObject *__pyx_v_tmp1 = 0;
  Vec *__pyx_v_isl;
  Py_ssize_t __pyx_v_nl;
  CYTHON_UNUSED PyObject *__pyx_v_tmp2 = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  Py_ssize_t __pyx_t_6;
  Vec __pyx_t_7;
  int __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setInitialSpaces", 0);
  __Pyx_INCREF(__pyx_v_spaceright);
  __Pyx_INCREF(__pyx_v_spaceleft);

  /* "SLEPc/SVD.pyx":699
 *            The left initial space.
 *         """
 *         cdef Py_ssize_t i = 0             # <<<<<<<<<<<<<<
 *         if spaceright is None: spaceright = []
 *         elif isinstance(spaceright, Vec): spaceright = [spaceright]
 */
  __pyx_v_i = 0;

  /* "SLEPc/SVD.pyx":700
 *         """
 *         cdef Py_ssize_t i = 0
 *         if spaceright is None: spaceright = []             # <<<<<<<<<<<<<<
 *         elif isinstance(spaceright, Vec): spaceright = [spaceright]
 *         cdef PetscVec *isr = NULL
 */
  __pyx_t_1 = (__pyx_v_spaceright == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 700, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_spaceright, __pyx_t_3);
    __pyx_t_3 = 0;
    goto __pyx_L3;
  }

  /* "SLEPc/SVD.pyx":701
 *         cdef Py_ssize_t i = 0
 *         if spaceright is None: spaceright = []
 *         elif isinstance(spaceright, Vec): spaceright = [spaceright]             # <<<<<<<<<<<<<<
 *         cdef PetscVec *isr = NULL
 *         cdef Py_ssize_t nr = len(spaceright)
 */
  __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_spaceright, __pyx_ptype_8petsc4py_5PETSc_Vec); 
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 701, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_spaceright);
    __Pyx_GIVEREF(__pyx_v_spaceright);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_spaceright);
    __Pyx_DECREF_SET(__pyx_v_spaceright, __pyx_t_3);
    __pyx_t_3 = 0;
  }
  __pyx_L3:;

  /* "SLEPc/SVD.pyx":702
 *         if spaceright is None: spaceright = []
 *         elif isinstance(spaceright, Vec): spaceright = [spaceright]
 *         cdef PetscVec *isr = NULL             # <<<<<<<<<<<<<<
 *         cdef Py_ssize_t nr = len(spaceright)
 *         cdef tmp1 = allocate(<size_t>nr*sizeof(PetscVec),<void**>&isr)
 */
  __pyx_v_isr = NULL;

  /* "SLEPc/SVD.pyx":703
 *         elif isinstance(spaceright, Vec): spaceright = [spaceright]
 *         cdef PetscVec *isr = NULL
 *         cdef Py_ssize_t nr = len(spaceright)             # <<<<<<<<<<<<<<
 *         cdef tmp1 = allocate(<size_t>nr*sizeof(PetscVec),<void**>&isr)
 *         for i in range(nr): isr[i] = (<Vec?>spaceright[i]).vec
 */
  __pyx_t_4 = PyObject_Length(__pyx_v_spaceright); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(18, 703, __pyx_L1_error)
  __pyx_v_nr = __pyx_t_4;

  /* "SLEPc/SVD.pyx":704
 *         cdef PetscVec *isr = NULL
 *         cdef Py_ssize_t nr = len(spaceright)
 *         cdef tmp1 = allocate(<size_t>nr*sizeof(PetscVec),<void**>&isr)             # <<<<<<<<<<<<<<
 *         for i in range(nr): isr[i] = (<Vec?>spaceright[i]).vec
 *         if spaceleft is None: spaceright = []
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_nr) * (sizeof(Vec))), ((void **)(&__pyx_v_isr))); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 704, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp1 = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/SVD.pyx":705
 *         cdef Py_ssize_t nr = len(spaceright)
 *         cdef tmp1 = allocate(<size_t>nr*sizeof(PetscVec),<void**>&isr)
 *         for i in range(nr): isr[i] = (<Vec?>spaceright[i]).vec             # <<<<<<<<<<<<<<
 *         if spaceleft is None: spaceright = []
 *         elif isinstance(spaceleft, Vec): spaceleft = [spaceleft]
 */
  __pyx_t_4 = __pyx_v_nr;
  __pyx_t_5 = __pyx_t_4;
  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
    __pyx_v_i = __pyx_t_6;
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_spaceright, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 705, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8petsc4py_5PETSc_Vec)))) __PYX_ERR(18, 705, __pyx_L1_error)
    __pyx_t_7 = ((struct PyPetscVecObject *)__pyx_t_3)->vec;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    (__pyx_v_isr[__pyx_v_i]) = __pyx_t_7;
  }

  /* "SLEPc/SVD.pyx":706
 *         cdef tmp1 = allocate(<size_t>nr*sizeof(PetscVec),<void**>&isr)
 *         for i in range(nr): isr[i] = (<Vec?>spaceright[i]).vec
 *         if spaceleft is None: spaceright = []             # <<<<<<<<<<<<<<
 *         elif isinstance(spaceleft, Vec): spaceleft = [spaceleft]
 *         cdef PetscVec *isl = NULL
 */
  __pyx_t_1 = (__pyx_v_spaceleft == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 706, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_spaceright, __pyx_t_3);
    __pyx_t_3 = 0;
    goto __pyx_L6;
  }

  /* "SLEPc/SVD.pyx":707
 *         for i in range(nr): isr[i] = (<Vec?>spaceright[i]).vec
 *         if spaceleft is None: spaceright = []
 *         elif isinstance(spaceleft, Vec): spaceleft = [spaceleft]             # <<<<<<<<<<<<<<
 *         cdef PetscVec *isl = NULL
 *         cdef Py_ssize_t nl = len(spaceleft)
 */
  __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_spaceleft, __pyx_ptype_8petsc4py_5PETSc_Vec); 
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 707, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_spaceleft);
    __Pyx_GIVEREF(__pyx_v_spaceleft);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_spaceleft);
    __Pyx_DECREF_SET(__pyx_v_spaceleft, __pyx_t_3);
    __pyx_t_3 = 0;
  }
  __pyx_L6:;

  /* "SLEPc/SVD.pyx":708
 *         if spaceleft is None: spaceright = []
 *         elif isinstance(spaceleft, Vec): spaceleft = [spaceleft]
 *         cdef PetscVec *isl = NULL             # <<<<<<<<<<<<<<
 *         cdef Py_ssize_t nl = len(spaceleft)
 *         cdef tmp2 = allocate(<size_t>nl*sizeof(PetscVec),<void**>&isl)
 */
  __pyx_v_isl = NULL;

  /* "SLEPc/SVD.pyx":709
 *         elif isinstance(spaceleft, Vec): spaceleft = [spaceleft]
 *         cdef PetscVec *isl = NULL
 *         cdef Py_ssize_t nl = len(spaceleft)             # <<<<<<<<<<<<<<
 *         cdef tmp2 = allocate(<size_t>nl*sizeof(PetscVec),<void**>&isl)
 *         for i in range(nl): isl[i] = (<Vec?>spaceleft[i]).vec
 */
  __pyx_t_4 = PyObject_Length(__pyx_v_spaceleft); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(18, 709, __pyx_L1_error)
  __pyx_v_nl = __pyx_t_4;

  /* "SLEPc/SVD.pyx":710
 *         cdef PetscVec *isl = NULL
 *         cdef Py_ssize_t nl = len(spaceleft)
 *         cdef tmp2 = allocate(<size_t>nl*sizeof(PetscVec),<void**>&isl)             # <<<<<<<<<<<<<<
 *         for i in range(nl): isl[i] = (<Vec?>spaceleft[i]).vec
 *         CHKERR( SVDSetInitialSpaces(self.svd, <PetscInt>nr, isr, <PetscInt>nl, isl) )
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_nl) * (sizeof(Vec))), ((void **)(&__pyx_v_isl))); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 710, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp2 = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/SVD.pyx":711
 *         cdef Py_ssize_t nl = len(spaceleft)
 *         cdef tmp2 = allocate(<size_t>nl*sizeof(PetscVec),<void**>&isl)
 *         for i in range(nl): isl[i] = (<Vec?>spaceleft[i]).vec             # <<<<<<<<<<<<<<
 *         CHKERR( SVDSetInitialSpaces(self.svd, <PetscInt>nr, isr, <PetscInt>nl, isl) )
 * 
 */
  __pyx_t_4 = __pyx_v_nl;
  __pyx_t_5 = __pyx_t_4;
  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
    __pyx_v_i = __pyx_t_6;
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_spaceleft, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 711, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8petsc4py_5PETSc_Vec)))) __PYX_ERR(18, 711, __pyx_L1_error)
    __pyx_t_7 = ((struct PyPetscVecObject *)__pyx_t_3)->vec;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    (__pyx_v_isl[__pyx_v_i]) = __pyx_t_7;
  }

  /* "SLEPc/SVD.pyx":712
 *         cdef tmp2 = allocate(<size_t>nl*sizeof(PetscVec),<void**>&isl)
 *         for i in range(nl): isl[i] = (<Vec?>spaceleft[i]).vec
 *         CHKERR( SVDSetInitialSpaces(self.svd, <PetscInt>nr, isr, <PetscInt>nl, isl) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_8 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetInitialSpaces(__pyx_v_self->svd, ((PetscInt)__pyx_v_nr), __pyx_v_isr, ((PetscInt)__pyx_v_nl), __pyx_v_isl)); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(18, 712, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":687
 *     #
 * 
 *     def setInitialSpaces(self, spaceright=None, spaceleft=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the initial spaces from which the SVD solver starts to
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setInitialSpaces", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp1);
  __Pyx_XDECREF(__pyx_v_tmp2);
  __Pyx_XDECREF(__pyx_v_spaceright);
  __Pyx_XDECREF(__pyx_v_spaceleft);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":716
 *     #
 * 
 *     def setStoppingTest(self, stopping, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_73setStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_72setStoppingTest[] = "SVD.setStoppingTest(self, stopping, args=None, kargs=None)\n\n        Sets a function to decide when to stop the outer iteration of the eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_73setStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_stopping = 0;
  PyObject *__pyx_v_args = 0;
  PyObject *__pyx_v_kargs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setStoppingTest (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_stopping,&__pyx_n_s_args,&__pyx_n_s_kargs,0};
    PyObject* values[3] = {0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_stopping)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kargs);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setStoppingTest") < 0)) __PYX_ERR(18, 716, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_stopping = values[0];
    __pyx_v_args = values[1];
    __pyx_v_kargs = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setStoppingTest", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 716, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setStoppingTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_72setStoppingTest(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_stopping, __pyx_v_args, __pyx_v_kargs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_72setStoppingTest(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_stopping, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setStoppingTest", 0);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);

  /* "SLEPc/SVD.pyx":720
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 *         """
 *         if stopping is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
  __pyx_t_1 = (__pyx_v_stopping != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "SLEPc/SVD.pyx":721
 *         """
 *         if stopping is not None:
 *             if args is None: args = ()             # <<<<<<<<<<<<<<
 *             if kargs is None: kargs = {}
 *             self.set_attr('__stopping__', (stopping, args, kargs))
 */
    __pyx_t_2 = (__pyx_v_args == Py_None);
    __pyx_t_1 = (__pyx_t_2 != 0);
    if (__pyx_t_1) {
      __Pyx_INCREF(__pyx_empty_tuple);
      __Pyx_DECREF_SET(__pyx_v_args, __pyx_empty_tuple);
    }

    /* "SLEPc/SVD.pyx":722
 *         if stopping is not None:
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}             # <<<<<<<<<<<<<<
 *             self.set_attr('__stopping__', (stopping, args, kargs))
 *             CHKERR( SVDSetStoppingTestFunction(self.svd, SVD_Stopping, NULL, NULL) )
 */
    __pyx_t_1 = (__pyx_v_kargs == Py_None);
    __pyx_t_2 = (__pyx_t_1 != 0);
    if (__pyx_t_2) {
      __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 722, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF_SET(__pyx_v_kargs, __pyx_t_3);
      __pyx_t_3 = 0;
    }

    /* "SLEPc/SVD.pyx":723
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 *             self.set_attr('__stopping__', (stopping, args, kargs))             # <<<<<<<<<<<<<<
 *             CHKERR( SVDSetStoppingTestFunction(self.svd, SVD_Stopping, NULL, NULL) )
 *         else:
 */
    __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 723, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_stopping);
    __Pyx_GIVEREF(__pyx_v_stopping);
    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_stopping);
    __Pyx_INCREF(__pyx_v_args);
    __Pyx_GIVEREF(__pyx_v_args);
    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_args);
    __Pyx_INCREF(__pyx_v_kargs);
    __Pyx_GIVEREF(__pyx_v_kargs);
    PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_kargs);
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_SVD *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__stopping__"), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 723, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "SLEPc/SVD.pyx":724
 *             if kargs is None: kargs = {}
 *             self.set_attr('__stopping__', (stopping, args, kargs))
 *             CHKERR( SVDSetStoppingTestFunction(self.svd, SVD_Stopping, NULL, NULL) )             # <<<<<<<<<<<<<<
 *         else:
 *             self.set_attr('__stopping__', None)
 */
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetStoppingTestFunction(__pyx_v_self->svd, __pyx_f_8slepc4py_5SLEPc_SVD_Stopping, NULL, NULL)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(18, 724, __pyx_L1_error)

    /* "SLEPc/SVD.pyx":720
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 *         """
 *         if stopping is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
    goto __pyx_L3;
  }

  /* "SLEPc/SVD.pyx":726
 *             CHKERR( SVDSetStoppingTestFunction(self.svd, SVD_Stopping, NULL, NULL) )
 *         else:
 *             self.set_attr('__stopping__', None)             # <<<<<<<<<<<<<<
 *             CHKERR( SVDSetStoppingTestFunction(self.svd, SVDStoppingBasic, NULL, NULL) )
 * 
 */
  /*else*/ {
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_SVD *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__stopping__"), Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 726, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "SLEPc/SVD.pyx":727
 *         else:
 *             self.set_attr('__stopping__', None)
 *             CHKERR( SVDSetStoppingTestFunction(self.svd, SVDStoppingBasic, NULL, NULL) )             # <<<<<<<<<<<<<<
 * 
 *     def getStoppingTest(self):
 */
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetStoppingTestFunction(__pyx_v_self->svd, SVDStoppingBasic, NULL, NULL)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(18, 727, __pyx_L1_error)
  }
  __pyx_L3:;

  /* "SLEPc/SVD.pyx":716
 *     #
 * 
 *     def setStoppingTest(self, stopping, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setStoppingTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":729
 *             CHKERR( SVDSetStoppingTestFunction(self.svd, SVDStoppingBasic, NULL, NULL) )
 * 
 *     def getStoppingTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the stopping function.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_75getStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_74getStoppingTest[] = "SVD.getStoppingTest(self)\n\n        Gets the stopping function.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_75getStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getStoppingTest (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getStoppingTest", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getStoppingTest", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_74getStoppingTest(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_74getStoppingTest(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getStoppingTest", 0);

  /* "SLEPc/SVD.pyx":733
 *         Gets the stopping function.
 *         """
 *         return self.get_attr('__stopping__')             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_SVD *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__stopping__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 733, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":729
 *             CHKERR( SVDSetStoppingTestFunction(self.svd, SVDStoppingBasic, NULL, NULL) )
 * 
 *     def getStoppingTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the stopping function.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getStoppingTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":737
 *     #
 * 
 *     def setMonitor(self, monitor, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Appends a monitor function to the list of monitors.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_77setMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_76setMonitor[] = "SVD.setMonitor(self, monitor, args=None, kargs=None)\n\n        Appends a monitor function to the list of monitors.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_77setMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_monitor = 0;
  PyObject *__pyx_v_args = 0;
  PyObject *__pyx_v_kargs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setMonitor (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_monitor,&__pyx_n_s_args,&__pyx_n_s_kargs,0};
    PyObject* values[3] = {0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_monitor)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kargs);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setMonitor") < 0)) __PYX_ERR(18, 737, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_monitor = values[0];
    __pyx_v_args = values[1];
    __pyx_v_kargs = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setMonitor", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 737, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_76setMonitor(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_monitor, __pyx_v_args, __pyx_v_kargs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_76setMonitor(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_monitor, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs) {
  PyObject *__pyx_v_monitorlist = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setMonitor", 0);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);

  /* "SLEPc/SVD.pyx":741
 *         Appends a monitor function to the list of monitors.
 *         """
 *         if monitor is None: return             # <<<<<<<<<<<<<<
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:
 */
  __pyx_t_1 = (__pyx_v_monitor == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;
  }

  /* "SLEPc/SVD.pyx":742
 *         """
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 *         if monitorlist is None:
 *             monitorlist = []
 */
  __pyx_t_3 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_SVD *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__")); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 742, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_monitorlist = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/SVD.pyx":743
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:             # <<<<<<<<<<<<<<
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 */
  __pyx_t_2 = (__pyx_v_monitorlist == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {

    /* "SLEPc/SVD.pyx":744
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:
 *             monitorlist = []             # <<<<<<<<<<<<<<
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( SVDMonitorSet(self.svd, SVD_Monitor, NULL, NULL) )
 */
    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 744, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_monitorlist, __pyx_t_3);
    __pyx_t_3 = 0;

    /* "SLEPc/SVD.pyx":745
 *         if monitorlist is None:
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)             # <<<<<<<<<<<<<<
 *             CHKERR( SVDMonitorSet(self.svd, SVD_Monitor, NULL, NULL) )
 *         if args is None: args = ()
 */
    __pyx_t_3 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_SVD *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__"), __pyx_v_monitorlist); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 745, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

    /* "SLEPc/SVD.pyx":746
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( SVDMonitorSet(self.svd, SVD_Monitor, NULL, NULL) )             # <<<<<<<<<<<<<<
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDMonitorSet(__pyx_v_self->svd, __pyx_f_8slepc4py_5SLEPc_SVD_Monitor, NULL, NULL)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(18, 746, __pyx_L1_error)

    /* "SLEPc/SVD.pyx":743
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:             # <<<<<<<<<<<<<<
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 */
  }

  /* "SLEPc/SVD.pyx":747
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( SVDMonitorSet(self.svd, SVD_Monitor, NULL, NULL) )
 *         if args is None: args = ()             # <<<<<<<<<<<<<<
 *         if kargs is None: kargs = {}
 *         monitorlist.append((monitor, args, kargs))
 */
  __pyx_t_1 = (__pyx_v_args == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __Pyx_INCREF(__pyx_empty_tuple);
    __Pyx_DECREF_SET(__pyx_v_args, __pyx_empty_tuple);
  }

  /* "SLEPc/SVD.pyx":748
 *             CHKERR( SVDMonitorSet(self.svd, SVD_Monitor, NULL, NULL) )
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}             # <<<<<<<<<<<<<<
 *         monitorlist.append((monitor, args, kargs))
 * 
 */
  __pyx_t_2 = (__pyx_v_kargs == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 748, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_kargs, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/SVD.pyx":749
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}
 *         monitorlist.append((monitor, args, kargs))             # <<<<<<<<<<<<<<
 * 
 *     def getMonitor(self):
 */
  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 749, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_monitor);
  __Pyx_GIVEREF(__pyx_v_monitor);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_monitor);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_GIVEREF(__pyx_v_args);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);
  __Pyx_GIVEREF(__pyx_v_kargs);
  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_kargs);
  __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_monitorlist, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(18, 749, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/SVD.pyx":737
 *     #
 * 
 *     def setMonitor(self, monitor, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Appends a monitor function to the list of monitors.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_monitorlist);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":751
 *         monitorlist.append((monitor, args, kargs))
 * 
 *     def getMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the list of monitor functions.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_79getMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_78getMonitor[] = "SVD.getMonitor(self)\n\n        Gets the list of monitor functions.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_79getMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getMonitor (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getMonitor", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getMonitor", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_78getMonitor(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_78getMonitor(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getMonitor", 0);

  /* "SLEPc/SVD.pyx":755
 *         Gets the list of monitor functions.
 *         """
 *         return self.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 * 
 *     def cancelMonitor(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_SVD *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 755, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":751
 *         monitorlist.append((monitor, args, kargs))
 * 
 *     def getMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the list of monitor functions.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":757
 *         return self.get_attr('__monitor__')
 * 
 *     def cancelMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Clears all monitors for an `SVD` object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_81cancelMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_80cancelMonitor[] = "SVD.cancelMonitor(self)\n\n        Clears all monitors for an `SVD` object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_81cancelMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("cancelMonitor (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("cancelMonitor", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "cancelMonitor", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_80cancelMonitor(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_80cancelMonitor(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("cancelMonitor", 0);

  /* "SLEPc/SVD.pyx":761
 *         Clears all monitors for an `SVD` object.
 *         """
 *         CHKERR( SVDMonitorCancel(self.svd) )             # <<<<<<<<<<<<<<
 *         self.set_attr('__monitor__', None)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDMonitorCancel(__pyx_v_self->svd)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 761, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":762
 *         """
 *         CHKERR( SVDMonitorCancel(self.svd) )
 *         self.set_attr('__monitor__', None)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_2 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_SVD *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__"), Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 762, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/SVD.pyx":757
 *         return self.get_attr('__monitor__')
 * 
 *     def cancelMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Clears all monitors for an `SVD` object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.cancelMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":766
 *     #
 * 
 *     def setUp(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets up all the internal data structures necessary for the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_83setUp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_82setUp[] = "SVD.setUp(self)\n\n        Sets up all the internal data structures necessary for the\n        execution of the singular value solver.\n\n        Notes\n        -----\n        This function need not be called explicitly in most cases,\n        since `solve()` calls it. It can be useful when one wants to\n        measure the set-up time separately from the solve time.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_83setUp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setUp (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setUp", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setUp", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_82setUp(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_82setUp(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setUp", 0);

  /* "SLEPc/SVD.pyx":777
 *         measure the set-up time separately from the solve time.
 *         """
 *         CHKERR( SVDSetUp(self.svd) )             # <<<<<<<<<<<<<<
 * 
 *     def solve(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSetUp(__pyx_v_self->svd)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 777, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":766
 *     #
 * 
 *     def setUp(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets up all the internal data structures necessary for the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setUp", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":779
 *         CHKERR( SVDSetUp(self.svd) )
 * 
 *     def solve(self):             # <<<<<<<<<<<<<<
 *         """
 *         Solves the singular value problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_85solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_84solve[] = "SVD.solve(self)\n\n        Solves the singular value problem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_85solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("solve (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("solve", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "solve", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_84solve(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_84solve(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("solve", 0);

  /* "SLEPc/SVD.pyx":783
 *         Solves the singular value problem.
 *         """
 *         CHKERR( SVDSolve(self.svd) )             # <<<<<<<<<<<<<<
 * 
 *     def getIterationNumber(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDSolve(__pyx_v_self->svd)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 783, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":779
 *         CHKERR( SVDSetUp(self.svd) )
 * 
 *     def solve(self):             # <<<<<<<<<<<<<<
 *         """
 *         Solves the singular value problem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.solve", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":785
 *         CHKERR( SVDSolve(self.svd) )
 * 
 *     def getIterationNumber(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the current iteration number. If the call to `solve()` is
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_87getIterationNumber(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_86getIterationNumber[] = "SVD.getIterationNumber(self)\n\n        Gets the current iteration number. If the call to `solve()` is\n        complete, then it returns the number of iterations carried out\n        by the solution method.\n\n        Returns\n        -------\n        its: int\n             Iteration number.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_87getIterationNumber(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getIterationNumber (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getIterationNumber", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getIterationNumber", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_86getIterationNumber(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_86getIterationNumber(struct PySlepcSVDObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getIterationNumber", 0);

  /* "SLEPc/SVD.pyx":796
 *              Iteration number.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetIterationNumber(self.svd, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/SVD.pyx":797
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( SVDGetIterationNumber(self.svd, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetIterationNumber(__pyx_v_self->svd, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 797, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":798
 *         cdef PetscInt ival = 0
 *         CHKERR( SVDGetIterationNumber(self.svd, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def getConvergedReason(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 798, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":785
 *         CHKERR( SVDSolve(self.svd) )
 * 
 *     def getIterationNumber(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the current iteration number. If the call to `solve()` is
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getIterationNumber", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":800
 *         return toInt(ival)
 * 
 *     def getConvergedReason(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the reason why the `solve()` iteration was stopped.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_89getConvergedReason(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_88getConvergedReason[] = "SVD.getConvergedReason(self)\n\n        Gets the reason why the `solve()` iteration was stopped.\n\n        Returns\n        -------\n        reason: `SVD.ConvergedReason` enumerate\n                Negative value indicates diverged, positive value\n                converged.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_89getConvergedReason(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getConvergedReason (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getConvergedReason", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConvergedReason", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_88getConvergedReason(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_88getConvergedReason(struct PySlepcSVDObject *__pyx_v_self) {
  SVDConvergedReason __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getConvergedReason", 0);

  /* "SLEPc/SVD.pyx":810
 *                 converged.
 *         """
 *         cdef SlepcSVDConvergedReason val = SVD_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetConvergedReason(self.svd, &val) )
 *         return val
 */
  __pyx_v_val = SVD_CONVERGED_ITERATING;

  /* "SLEPc/SVD.pyx":811
 *         """
 *         cdef SlepcSVDConvergedReason val = SVD_CONVERGED_ITERATING
 *         CHKERR( SVDGetConvergedReason(self.svd, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetConvergedReason(__pyx_v_self->svd, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 811, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":812
 *         cdef SlepcSVDConvergedReason val = SVD_CONVERGED_ITERATING
 *         CHKERR( SVDGetConvergedReason(self.svd, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def getConverged(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_SVDConvergedReason(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 812, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":800
 *         return toInt(ival)
 * 
 *     def getConvergedReason(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the reason why the `solve()` iteration was stopped.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getConvergedReason", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":814
 *         return val
 * 
 *     def getConverged(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of converged singular triplets.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_91getConverged(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_90getConverged[] = "SVD.getConverged(self)\n\n        Gets the number of converged singular triplets.\n\n        Returns\n        -------\n        nconv: int\n               Number of converged singular triplets.\n\n        Notes\n        -----\n        This function should be called after `solve()` has finished.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_91getConverged(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getConverged (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getConverged", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConverged", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_90getConverged(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_90getConverged(struct PySlepcSVDObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getConverged", 0);

  /* "SLEPc/SVD.pyx":827
 *         This function should be called after `solve()` has finished.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetConverged(self.svd, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/SVD.pyx":828
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( SVDGetConverged(self.svd, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetConverged(__pyx_v_self->svd, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 828, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":829
 *         cdef PetscInt ival = 0
 *         CHKERR( SVDGetConverged(self.svd, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def getValue(self, int i):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 829, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":814
 *         return val
 * 
 *     def getConverged(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of converged singular triplets.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getConverged", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":831
 *         return toInt(ival)
 * 
 *     def getValue(self, int i):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th singular value as computed by `solve()`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_93getValue(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_92getValue[] = "SVD.getValue(self, int i)\n\n        Gets the i-th singular value as computed by `solve()`.\n\n        Parameters\n        ----------\n        i: int\n           Index of the solution to be obtained.\n\n        Returns\n        -------\n        s: float\n           The computed singular value.\n\n        Notes\n        -----\n        The index ``i`` should be a value between ``0`` and\n        ``nconv-1`` (see `getConverged()`. Singular triplets are\n        indexed according to the ordering criterion established with\n        `setWhichSingularTriplets()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_93getValue(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getValue (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getValue") < 0)) __PYX_ERR(18, 831, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(18, 831, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getValue", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 831, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getValue", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_92getValue(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_i);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_92getValue(struct PySlepcSVDObject *__pyx_v_self, int __pyx_v_i) {
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getValue", 0);

  /* "SLEPc/SVD.pyx":852
 *         `setWhichSingularTriplets()`.
 *         """
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetSingularTriplet(self.svd, i, &rval, NULL, NULL) )
 *         return toReal(rval)
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/SVD.pyx":853
 *         """
 *         cdef PetscReal rval = 0
 *         CHKERR( SVDGetSingularTriplet(self.svd, i, &rval, NULL, NULL) )             # <<<<<<<<<<<<<<
 *         return toReal(rval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetSingularTriplet(__pyx_v_self->svd, __pyx_v_i, (&__pyx_v_rval), NULL, NULL)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 853, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":854
 *         cdef PetscReal rval = 0
 *         CHKERR( SVDGetSingularTriplet(self.svd, i, &rval, NULL, NULL) )
 *         return toReal(rval)             # <<<<<<<<<<<<<<
 * 
 *     def getVectors(self, int i, Vec U, Vec V):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 854, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":831
 *         return toInt(ival)
 * 
 *     def getValue(self, int i):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th singular value as computed by `solve()`.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getValue", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":856
 *         return toReal(rval)
 * 
 *     def getVectors(self, int i, Vec U, Vec V):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th left and right singular vectors as computed by
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_95getVectors(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_94getVectors[] = "SVD.getVectors(self, int i, Vec U, Vec V)\n\n        Gets the i-th left and right singular vectors as computed by\n        `solve()`.\n\n        Parameters\n        ----------\n        i: int\n           Index of the solution to be obtained.\n        U: Vec\n           Placeholder for the returned left singular vector.\n        V: Vec\n           Placeholder for the returned right singular vector.\n\n        Notes\n        -----\n        The index ``i`` should be a value between ``0`` and\n        ``nconv-1`` (see `getConverged()`. Singular triplets are\n        indexed according to the ordering criterion established with\n        `setWhichSingularTriplets()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_95getVectors(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  struct PyPetscVecObject *__pyx_v_U = 0;
  struct PyPetscVecObject *__pyx_v_V = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getVectors (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,&__pyx_n_s_U,&__pyx_n_s_V,0};
    PyObject* values[3] = {0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_U)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("getVectors", 1, 3, 3, 1); __PYX_ERR(18, 856, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_V)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("getVectors", 1, 3, 3, 2); __PYX_ERR(18, 856, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getVectors") < 0)) __PYX_ERR(18, 856, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(18, 856, __pyx_L3_error)
    __pyx_v_U = ((struct PyPetscVecObject *)values[1]);
    __pyx_v_V = ((struct PyPetscVecObject *)values[2]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getVectors", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 856, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getVectors", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_U), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "U", 0))) __PYX_ERR(18, 856, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_V), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "V", 0))) __PYX_ERR(18, 856, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_94getVectors(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_i, __pyx_v_U, __pyx_v_V);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_94getVectors(struct PySlepcSVDObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_U, struct PyPetscVecObject *__pyx_v_V) {
  PetscReal __pyx_v_dummy;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getVectors", 0);

  /* "SLEPc/SVD.pyx":877
 *         `setWhichSingularTriplets()`.
 *         """
 *         cdef PetscReal dummy = 0             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetSingularTriplet(self.svd, i, &dummy, U.vec, V.vec) )
 * 
 */
  __pyx_v_dummy = 0.0;

  /* "SLEPc/SVD.pyx":878
 *         """
 *         cdef PetscReal dummy = 0
 *         CHKERR( SVDGetSingularTriplet(self.svd, i, &dummy, U.vec, V.vec) )             # <<<<<<<<<<<<<<
 * 
 *     def getSingularTriplet(self, int i, Vec U=None, Vec V=None):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetSingularTriplet(__pyx_v_self->svd, __pyx_v_i, (&__pyx_v_dummy), __pyx_v_U->vec, __pyx_v_V->vec)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 878, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":856
 *         return toReal(rval)
 * 
 *     def getVectors(self, int i, Vec U, Vec V):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th left and right singular vectors as computed by
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getVectors", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":880
 *         CHKERR( SVDGetSingularTriplet(self.svd, i, &dummy, U.vec, V.vec) )
 * 
 *     def getSingularTriplet(self, int i, Vec U=None, Vec V=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th triplet of the singular value decomposition as
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_97getSingularTriplet(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_96getSingularTriplet[] = "SVD.getSingularTriplet(self, int i, Vec U=None, Vec V=None)\n\n        Gets the i-th triplet of the singular value decomposition as\n        computed by `solve()`. The solution consists of the singular\n        value and its left and right singular vectors.\n\n        Parameters\n        ----------\n        i: int\n           Index of the solution to be obtained.\n        U: Vec\n           Placeholder for the returned left singular vector.\n        V: Vec\n           Placeholder for the returned right singular vector.\n\n        Returns\n        -------\n        s: float\n           The computed singular value.\n\n        Notes\n        -----\n        The index ``i`` should be a value between ``0`` and\n        ``nconv-1`` (see `getConverged()`. Singular triplets are\n        indexed according to the ordering criterion established with\n        `setWhichSingularTriplets()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_97getSingularTriplet(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  struct PyPetscVecObject *__pyx_v_U = 0;
  struct PyPetscVecObject *__pyx_v_V = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSingularTriplet (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,&__pyx_n_s_U,&__pyx_n_s_V,0};
    PyObject* values[3] = {0,0,0};
    values[1] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    values[2] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_U);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_V);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getSingularTriplet") < 0)) __PYX_ERR(18, 880, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(18, 880, __pyx_L3_error)
    __pyx_v_U = ((struct PyPetscVecObject *)values[1]);
    __pyx_v_V = ((struct PyPetscVecObject *)values[2]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getSingularTriplet", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 880, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getSingularTriplet", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_U), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "U", 0))) __PYX_ERR(18, 880, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_V), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "V", 0))) __PYX_ERR(18, 880, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_96getSingularTriplet(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_i, __pyx_v_U, __pyx_v_V);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_96getSingularTriplet(struct PySlepcSVDObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_U, struct PyPetscVecObject *__pyx_v_V) {
  PetscReal __pyx_v_rval;
  Vec __pyx_v_Uvec;
  Vec __pyx_v_Vvec;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Vec __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSingularTriplet", 0);

  /* "SLEPc/SVD.pyx":907
 *         `setWhichSingularTriplets()`.
 *         """
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         cdef PetscVec Uvec = U.vec if U is not None else <PetscVec>NULL
 *         cdef PetscVec Vvec = V.vec if V is not None else <PetscVec>NULL
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/SVD.pyx":908
 *         """
 *         cdef PetscReal rval = 0
 *         cdef PetscVec Uvec = U.vec if U is not None else <PetscVec>NULL             # <<<<<<<<<<<<<<
 *         cdef PetscVec Vvec = V.vec if V is not None else <PetscVec>NULL
 *         CHKERR( SVDGetSingularTriplet(self.svd, i, &rval, Uvec, Vvec) )
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_U) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_U->vec;
  } else {
    __pyx_t_1 = ((Vec)NULL);
  }
  __pyx_v_Uvec = __pyx_t_1;

  /* "SLEPc/SVD.pyx":909
 *         cdef PetscReal rval = 0
 *         cdef PetscVec Uvec = U.vec if U is not None else <PetscVec>NULL
 *         cdef PetscVec Vvec = V.vec if V is not None else <PetscVec>NULL             # <<<<<<<<<<<<<<
 *         CHKERR( SVDGetSingularTriplet(self.svd, i, &rval, Uvec, Vvec) )
 *         return toReal(rval)
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_V) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_V->vec;
  } else {
    __pyx_t_1 = ((Vec)NULL);
  }
  __pyx_v_Vvec = __pyx_t_1;

  /* "SLEPc/SVD.pyx":910
 *         cdef PetscVec Uvec = U.vec if U is not None else <PetscVec>NULL
 *         cdef PetscVec Vvec = V.vec if V is not None else <PetscVec>NULL
 *         CHKERR( SVDGetSingularTriplet(self.svd, i, &rval, Uvec, Vvec) )             # <<<<<<<<<<<<<<
 *         return toReal(rval)
 * 
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDGetSingularTriplet(__pyx_v_self->svd, __pyx_v_i, (&__pyx_v_rval), __pyx_v_Uvec, __pyx_v_Vvec)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(18, 910, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":911
 *         cdef PetscVec Vvec = V.vec if V is not None else <PetscVec>NULL
 *         CHKERR( SVDGetSingularTriplet(self.svd, i, &rval, Uvec, Vvec) )
 *         return toReal(rval)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 911, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":880
 *         CHKERR( SVDGetSingularTriplet(self.svd, i, &dummy, U.vec, V.vec) )
 * 
 *     def getSingularTriplet(self, int i, Vec U=None, Vec V=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th triplet of the singular value decomposition as
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getSingularTriplet", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":915
 *     #
 * 
 *     def computeError(self, int i, etype=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the error (based on the residual norm) associated with the i-th
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_99computeError(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_98computeError[] = "SVD.computeError(self, int i, etype=None)\n\n        Computes the error (based on the residual norm) associated with the i-th\n        singular triplet.\n\n        Parameters\n        ----------\n        i: int\n           Index of the solution to be considered.\n        etype: `SVD.ErrorType` enumerate\n           The error type to compute.\n\n        Returns\n        -------\n        e: real\n           The relative error bound, computed in various ways from the residual norm\n           ``sqrt(n1^2+n2^2)`` where ``n1 = ||A*v-sigma*u||_2``,\n           ``n2 = ||A^T*u-sigma*v||_2``, ``sigma`` is the singular\n           value, ``u`` and ``v`` are the left and right singular\n           vectors.\n\n        Notes\n        -----\n        The index ``i`` should be a value between ``0`` and\n        ``nconv-1`` (see `getConverged()`).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_99computeError(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  PyObject *__pyx_v_etype = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("computeError (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,&__pyx_n_s_etype,0};
    PyObject* values[2] = {0,0};
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_etype);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "computeError") < 0)) __PYX_ERR(18, 915, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(18, 915, __pyx_L3_error)
    __pyx_v_etype = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("computeError", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 915, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.computeError", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_98computeError(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_i, __pyx_v_etype);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_98computeError(struct PySlepcSVDObject *__pyx_v_self, int __pyx_v_i, PyObject *__pyx_v_etype) {
  SVDErrorType __pyx_v_et;
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  SVDErrorType __pyx_t_3;
  int __pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("computeError", 0);

  /* "SLEPc/SVD.pyx":941
 *         ``nconv-1`` (see `getConverged()`).
 *         """
 *         cdef SlepcSVDErrorType et = SVD_ERROR_RELATIVE             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval = 0
 *         if etype is not None: et = etype
 */
  __pyx_v_et = SVD_ERROR_RELATIVE;

  /* "SLEPc/SVD.pyx":942
 *         """
 *         cdef SlepcSVDErrorType et = SVD_ERROR_RELATIVE
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         if etype is not None: et = etype
 *         CHKERR( SVDComputeError(self.svd, i, et, &rval) )
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/SVD.pyx":943
 *         cdef SlepcSVDErrorType et = SVD_ERROR_RELATIVE
 *         cdef PetscReal rval = 0
 *         if etype is not None: et = etype             # <<<<<<<<<<<<<<
 *         CHKERR( SVDComputeError(self.svd, i, et, &rval) )
 *         return toReal(rval)
 */
  __pyx_t_1 = (__pyx_v_etype != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = ((SVDErrorType)__Pyx_PyInt_As_SVDErrorType(__pyx_v_etype)); if (unlikely(PyErr_Occurred())) __PYX_ERR(18, 943, __pyx_L1_error)
    __pyx_v_et = __pyx_t_3;
  }

  /* "SLEPc/SVD.pyx":944
 *         cdef PetscReal rval = 0
 *         if etype is not None: et = etype
 *         CHKERR( SVDComputeError(self.svd, i, et, &rval) )             # <<<<<<<<<<<<<<
 *         return toReal(rval)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDComputeError(__pyx_v_self->svd, __pyx_v_i, __pyx_v_et, (&__pyx_v_rval))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(18, 944, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":945
 *         if etype is not None: et = etype
 *         CHKERR( SVDComputeError(self.svd, i, et, &rval) )
 *         return toReal(rval)             # <<<<<<<<<<<<<<
 * 
 *     def errorView(self, etype=None, Viewer viewer=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_5)) __PYX_ERR(18, 945, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":915
 *     #
 * 
 *     def computeError(self, int i, etype=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the error (based on the residual norm) associated with the i-th
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.computeError", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":947
 *         return toReal(rval)
 * 
 *     def errorView(self, etype=None, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the errors associated with the computed solution
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_101errorView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_100errorView[] = "SVD.errorView(self, etype=None, Viewer viewer=None)\n\n        Displays the errors associated with the computed solution\n        (as well as the eigenvalues).\n\n        Parameters\n        ----------\n        etype: `SVD.ErrorType` enumerate, optional\n           The error type to compute.\n        viewer: Viewer, optional.\n                Visualization context; if not provided, the standard\n                output is used.\n\n        Notes\n        -----\n        By default, this function checks the error of all eigenpairs and prints\n        the eigenvalues if all of them are below the requested tolerance.\n        If the viewer has format ``ASCII_INFO_DETAIL`` then a table with\n        eigenvalues and corresponding errors is printed.\n\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_101errorView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_etype = 0;
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("errorView (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_etype,&__pyx_n_s_viewer,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_etype);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "errorView") < 0)) __PYX_ERR(18, 947, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_etype = values[0];
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("errorView", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 947, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.errorView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(18, 947, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_100errorView(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_etype, __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_100errorView(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_etype, struct PyPetscViewerObject *__pyx_v_viewer) {
  SVDErrorType __pyx_v_et;
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  SVDErrorType __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("errorView", 0);

  /* "SLEPc/SVD.pyx":968
 * 
 *         """
 *         cdef SlepcSVDErrorType et = SVD_ERROR_RELATIVE             # <<<<<<<<<<<<<<
 *         if etype is not None: et = etype
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 */
  __pyx_v_et = SVD_ERROR_RELATIVE;

  /* "SLEPc/SVD.pyx":969
 *         """
 *         cdef SlepcSVDErrorType et = SVD_ERROR_RELATIVE
 *         if etype is not None: et = etype             # <<<<<<<<<<<<<<
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( SVDErrorView(self.svd, et, vwr) )
 */
  __pyx_t_1 = (__pyx_v_etype != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = ((SVDErrorType)__Pyx_PyInt_As_SVDErrorType(__pyx_v_etype)); if (unlikely(PyErr_Occurred())) __PYX_ERR(18, 969, __pyx_L1_error)
    __pyx_v_et = __pyx_t_3;
  }

  /* "SLEPc/SVD.pyx":970
 *         cdef SlepcSVDErrorType et = SVD_ERROR_RELATIVE
 *         if etype is not None: et = etype
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDErrorView(self.svd, et, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/SVD.pyx":971
 *         if etype is not None: et = etype
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( SVDErrorView(self.svd, et, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def valuesView(self, Viewer viewer=None):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDErrorView(__pyx_v_self->svd, __pyx_v_et, __pyx_v_vwr)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(18, 971, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":947
 *         return toReal(rval)
 * 
 *     def errorView(self, etype=None, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the errors associated with the computed solution
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.errorView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":973
 *         CHKERR( SVDErrorView(self.svd, et, vwr) )
 * 
 *     def valuesView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the computed singular values in a viewer.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_103valuesView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_102valuesView[] = "SVD.valuesView(self, Viewer viewer=None)\n\n        Displays the computed singular values in a viewer.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional.\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_103valuesView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("valuesView (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "valuesView") < 0)) __PYX_ERR(18, 973, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("valuesView", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 973, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.valuesView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(18, 973, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_102valuesView(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_102valuesView(struct PySlepcSVDObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("valuesView", 0);

  /* "SLEPc/SVD.pyx":983
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDValuesView(self.svd, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/SVD.pyx":984
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( SVDValuesView(self.svd, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def vectorsView(self, Viewer viewer=None):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDValuesView(__pyx_v_self->svd, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 984, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":973
 *         CHKERR( SVDErrorView(self.svd, et, vwr) )
 * 
 *     def valuesView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the computed singular values in a viewer.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.valuesView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":986
 *         CHKERR( SVDValuesView(self.svd, vwr) )
 * 
 *     def vectorsView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Outputs computed singular vectors to a viewer.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_105vectorsView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_104vectorsView[] = "SVD.vectorsView(self, Viewer viewer=None)\n\n        Outputs computed singular vectors to a viewer.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional.\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_105vectorsView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("vectorsView (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "vectorsView") < 0)) __PYX_ERR(18, 986, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("vectorsView", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 986, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.vectorsView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(18, 986, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_104vectorsView(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_104vectorsView(struct PySlepcSVDObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("vectorsView", 0);

  /* "SLEPc/SVD.pyx":996
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDVectorsView(self.svd, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/SVD.pyx":997
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( SVDVectorsView(self.svd, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDVectorsView(__pyx_v_self->svd, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 997, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":986
 *         CHKERR( SVDValuesView(self.svd, vwr) )
 * 
 *     def vectorsView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Outputs computed singular vectors to a viewer.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.vectorsView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1001
 *     #
 * 
 *     def setCrossEPS(self, EPS eps):             # <<<<<<<<<<<<<<
 *         """
 *         Associate an eigensolver object (`EPS`) to the singular value
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_107setCrossEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_106setCrossEPS[] = "SVD.setCrossEPS(self, EPS eps)\n\n        Associate an eigensolver object (`EPS`) to the singular value\n        solver.\n\n        Parameters\n        ----------\n        eps: EPS\n             The eigensolver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_107setCrossEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcEPSObject *__pyx_v_eps = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCrossEPS (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_eps,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_eps)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCrossEPS") < 0)) __PYX_ERR(18, 1001, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_eps = ((struct PySlepcEPSObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCrossEPS", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 1001, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setCrossEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_eps), __pyx_ptype_8slepc4py_5SLEPc_EPS, 0, "eps", 0))) __PYX_ERR(18, 1001, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_106setCrossEPS(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_eps);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_106setCrossEPS(struct PySlepcSVDObject *__pyx_v_self, struct PySlepcEPSObject *__pyx_v_eps) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCrossEPS", 0);

  /* "SLEPc/SVD.pyx":1011
 *              The eigensolver object.
 *         """
 *         CHKERR( SVDCrossSetEPS(self.svd, eps.eps) )             # <<<<<<<<<<<<<<
 * 
 *     def getCrossEPS(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDCrossSetEPS(__pyx_v_self->svd, __pyx_v_eps->eps)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 1011, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1001
 *     #
 * 
 *     def setCrossEPS(self, EPS eps):             # <<<<<<<<<<<<<<
 *         """
 *         Associate an eigensolver object (`EPS`) to the singular value
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setCrossEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1013
 *         CHKERR( SVDCrossSetEPS(self.svd, eps.eps) )
 * 
 *     def getCrossEPS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the eigensolver object (`EPS`) associated to the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_109getCrossEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_108getCrossEPS[] = "SVD.getCrossEPS(self)\n\n        Retrieve the eigensolver object (`EPS`) associated to the\n        singular value solver.\n\n        Returns\n        -------\n        eps: EPS\n             The eigensolver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_109getCrossEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCrossEPS (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCrossEPS", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCrossEPS", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_108getCrossEPS(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_108getCrossEPS(struct PySlepcSVDObject *__pyx_v_self) {
  struct PySlepcEPSObject *__pyx_v_eps = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCrossEPS", 0);

  /* "SLEPc/SVD.pyx":1023
 *              The eigensolver object.
 *         """
 *         cdef EPS eps = EPS()             # <<<<<<<<<<<<<<
 *         CHKERR( SVDCrossGetEPS(self.svd, &eps.eps) )
 *         PetscINCREF(eps.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1023, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_eps = ((struct PySlepcEPSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":1024
 *         """
 *         cdef EPS eps = EPS()
 *         CHKERR( SVDCrossGetEPS(self.svd, &eps.eps) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(eps.obj)
 *         return eps
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDCrossGetEPS(__pyx_v_self->svd, (&__pyx_v_eps->eps))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 1024, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1025
 *         cdef EPS eps = EPS()
 *         CHKERR( SVDCrossGetEPS(self.svd, &eps.eps) )
 *         PetscINCREF(eps.obj)             # <<<<<<<<<<<<<<
 *         return eps
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_eps->__pyx_base.obj));

  /* "SLEPc/SVD.pyx":1026
 *         CHKERR( SVDCrossGetEPS(self.svd, &eps.eps) )
 *         PetscINCREF(eps.obj)
 *         return eps             # <<<<<<<<<<<<<<
 * 
 *     def setCrossExplicitMatrix(self, flag=True):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_eps));
  __pyx_r = ((PyObject *)__pyx_v_eps);
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1013
 *         CHKERR( SVDCrossSetEPS(self.svd, eps.eps) )
 * 
 *     def getCrossEPS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the eigensolver object (`EPS`) associated to the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getCrossEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_eps);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1028
 *         return eps
 * 
 *     def setCrossExplicitMatrix(self, flag=True):             # <<<<<<<<<<<<<<
 *         """
 *         Indicate if the eigensolver operator ``A^T*A`` must be
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_111setCrossExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_110setCrossExplicitMatrix[] = "SVD.setCrossExplicitMatrix(self, flag=True)\n\n        Indicate if the eigensolver operator ``A^T*A`` must be\n        computed explicitly.\n\n        Parameters\n        ----------\n        flag: bool\n              True if ``A^T*A`` is built explicitly.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_111setCrossExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_flag = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCrossExplicitMatrix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flag,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flag);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCrossExplicitMatrix") < 0)) __PYX_ERR(18, 1028, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_flag = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCrossExplicitMatrix", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 1028, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setCrossExplicitMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_110setCrossExplicitMatrix(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_flag);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_110setCrossExplicitMatrix(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_flag) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCrossExplicitMatrix", 0);

  /* "SLEPc/SVD.pyx":1038
 *               True if ``A^T*A`` is built explicitly.
 *         """
 *         cdef PetscBool tval = asBool(flag)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDCrossSetExplicitMatrix(self.svd, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_flag); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(18, 1038, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/SVD.pyx":1039
 *         """
 *         cdef PetscBool tval = asBool(flag)
 *         CHKERR( SVDCrossSetExplicitMatrix(self.svd, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getCrossExplicitMatrix(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDCrossSetExplicitMatrix(__pyx_v_self->svd, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 1039, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1028
 *         return eps
 * 
 *     def setCrossExplicitMatrix(self, flag=True):             # <<<<<<<<<<<<<<
 *         """
 *         Indicate if the eigensolver operator ``A^T*A`` must be
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setCrossExplicitMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1041
 *         CHKERR( SVDCrossSetExplicitMatrix(self.svd, tval) )
 * 
 *     def getCrossExplicitMatrix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating if ``A^T*A`` is built explicitly.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_113getCrossExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_112getCrossExplicitMatrix[] = "SVD.getCrossExplicitMatrix(self)\n\n        Returns the flag indicating if ``A^T*A`` is built explicitly.\n\n        Returns\n        -------\n        flag: bool\n              True if ``A^T*A`` is built explicitly.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_113getCrossExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCrossExplicitMatrix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCrossExplicitMatrix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCrossExplicitMatrix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_112getCrossExplicitMatrix(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_112getCrossExplicitMatrix(struct PySlepcSVDObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCrossExplicitMatrix", 0);

  /* "SLEPc/SVD.pyx":1050
 *               True if ``A^T*A`` is built explicitly.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( SVDCrossGetExplicitMatrix(self.svd, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/SVD.pyx":1051
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDCrossGetExplicitMatrix(self.svd, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDCrossGetExplicitMatrix(__pyx_v_self->svd, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 1051, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1052
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDCrossGetExplicitMatrix(self.svd, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setCyclicEPS(self, EPS eps):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1052, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1041
 *         CHKERR( SVDCrossSetExplicitMatrix(self.svd, tval) )
 * 
 *     def getCrossExplicitMatrix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating if ``A^T*A`` is built explicitly.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getCrossExplicitMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1054
 *         return toBool(tval)
 * 
 *     def setCyclicEPS(self, EPS eps):             # <<<<<<<<<<<<<<
 *         """
 *         Associate an eigensolver object (`EPS`) to the singular value
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_115setCyclicEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_114setCyclicEPS[] = "SVD.setCyclicEPS(self, EPS eps)\n\n        Associate an eigensolver object (`EPS`) to the singular value\n        solver.\n\n        Parameters\n        ----------\n        eps: EPS\n             The eigensolver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_115setCyclicEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcEPSObject *__pyx_v_eps = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCyclicEPS (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_eps,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_eps)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCyclicEPS") < 0)) __PYX_ERR(18, 1054, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_eps = ((struct PySlepcEPSObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCyclicEPS", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 1054, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setCyclicEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_eps), __pyx_ptype_8slepc4py_5SLEPc_EPS, 0, "eps", 0))) __PYX_ERR(18, 1054, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_114setCyclicEPS(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_eps);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_114setCyclicEPS(struct PySlepcSVDObject *__pyx_v_self, struct PySlepcEPSObject *__pyx_v_eps) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCyclicEPS", 0);

  /* "SLEPc/SVD.pyx":1064
 *              The eigensolver object.
 *         """
 *         CHKERR( SVDCyclicSetEPS(self.svd, eps.eps) )             # <<<<<<<<<<<<<<
 * 
 *     def getCyclicEPS(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDCyclicSetEPS(__pyx_v_self->svd, __pyx_v_eps->eps)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 1064, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1054
 *         return toBool(tval)
 * 
 *     def setCyclicEPS(self, EPS eps):             # <<<<<<<<<<<<<<
 *         """
 *         Associate an eigensolver object (`EPS`) to the singular value
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setCyclicEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1066
 *         CHKERR( SVDCyclicSetEPS(self.svd, eps.eps) )
 * 
 *     def getCyclicEPS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the eigensolver object (`EPS`) associated to the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_117getCyclicEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_116getCyclicEPS[] = "SVD.getCyclicEPS(self)\n\n        Retrieve the eigensolver object (`EPS`) associated to the\n        singular value solver.\n\n        Returns\n        -------\n        eps: EPS\n             The eigensolver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_117getCyclicEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCyclicEPS (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCyclicEPS", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCyclicEPS", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_116getCyclicEPS(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_116getCyclicEPS(struct PySlepcSVDObject *__pyx_v_self) {
  struct PySlepcEPSObject *__pyx_v_eps = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCyclicEPS", 0);

  /* "SLEPc/SVD.pyx":1076
 *              The eigensolver object.
 *         """
 *         cdef EPS eps = EPS()             # <<<<<<<<<<<<<<
 *         CHKERR( SVDCyclicGetEPS(self.svd, &eps.eps) )
 *         PetscINCREF(eps.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1076, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_eps = ((struct PySlepcEPSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":1077
 *         """
 *         cdef EPS eps = EPS()
 *         CHKERR( SVDCyclicGetEPS(self.svd, &eps.eps) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(eps.obj)
 *         return eps
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDCyclicGetEPS(__pyx_v_self->svd, (&__pyx_v_eps->eps))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 1077, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1078
 *         cdef EPS eps = EPS()
 *         CHKERR( SVDCyclicGetEPS(self.svd, &eps.eps) )
 *         PetscINCREF(eps.obj)             # <<<<<<<<<<<<<<
 *         return eps
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_eps->__pyx_base.obj));

  /* "SLEPc/SVD.pyx":1079
 *         CHKERR( SVDCyclicGetEPS(self.svd, &eps.eps) )
 *         PetscINCREF(eps.obj)
 *         return eps             # <<<<<<<<<<<<<<
 * 
 *     def setCyclicExplicitMatrix(self, flag=True):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_eps));
  __pyx_r = ((PyObject *)__pyx_v_eps);
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1066
 *         CHKERR( SVDCyclicSetEPS(self.svd, eps.eps) )
 * 
 *     def getCyclicEPS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the eigensolver object (`EPS`) associated to the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getCyclicEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_eps);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1081
 *         return eps
 * 
 *     def setCyclicExplicitMatrix(self, flag=True):             # <<<<<<<<<<<<<<
 *         """
 *         Indicate if the eigensolver operator ``H(A) = [ 0 A ; A^T 0
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_119setCyclicExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_118setCyclicExplicitMatrix[] = "SVD.setCyclicExplicitMatrix(self, flag=True)\n\n        Indicate if the eigensolver operator ``H(A) = [ 0 A ; A^T 0\n        ]`` must be computed explicitly.\n\n        Parameters\n        ----------\n        flag: bool\n              True if ``H(A)`` is built explicitly.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_119setCyclicExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_flag = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCyclicExplicitMatrix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flag,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flag);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCyclicExplicitMatrix") < 0)) __PYX_ERR(18, 1081, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_flag = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCyclicExplicitMatrix", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 1081, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setCyclicExplicitMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_118setCyclicExplicitMatrix(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_flag);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_118setCyclicExplicitMatrix(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_flag) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCyclicExplicitMatrix", 0);

  /* "SLEPc/SVD.pyx":1091
 *               True if ``H(A)`` is built explicitly.
 *         """
 *         cdef PetscBool tval = asBool(flag)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDCyclicSetExplicitMatrix(self.svd, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_flag); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(18, 1091, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/SVD.pyx":1092
 *         """
 *         cdef PetscBool tval = asBool(flag)
 *         CHKERR( SVDCyclicSetExplicitMatrix(self.svd, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getCyclicExplicitMatrix(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDCyclicSetExplicitMatrix(__pyx_v_self->svd, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 1092, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1081
 *         return eps
 * 
 *     def setCyclicExplicitMatrix(self, flag=True):             # <<<<<<<<<<<<<<
 *         """
 *         Indicate if the eigensolver operator ``H(A) = [ 0 A ; A^T 0
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setCyclicExplicitMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1094
 *         CHKERR( SVDCyclicSetExplicitMatrix(self.svd, tval) )
 * 
 *     def getCyclicExplicitMatrix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating if ``H(A) = [ 0 A ; A^T 0 ]`` is
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_121getCyclicExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_120getCyclicExplicitMatrix[] = "SVD.getCyclicExplicitMatrix(self)\n\n        Returns the flag indicating if ``H(A) = [ 0 A ; A^T 0 ]`` is\n        built explicitly.\n\n        Returns\n        -------\n        flag: bool\n              True if ``H(A)`` is built explicitly.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_121getCyclicExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCyclicExplicitMatrix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCyclicExplicitMatrix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCyclicExplicitMatrix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_120getCyclicExplicitMatrix(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_120getCyclicExplicitMatrix(struct PySlepcSVDObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCyclicExplicitMatrix", 0);

  /* "SLEPc/SVD.pyx":1104
 *               True if ``H(A)`` is built explicitly.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( SVDCyclicGetExplicitMatrix(self.svd, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/SVD.pyx":1105
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDCyclicGetExplicitMatrix(self.svd, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDCyclicGetExplicitMatrix(__pyx_v_self->svd, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 1105, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1106
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDCyclicGetExplicitMatrix(self.svd, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setLanczosOneSide(self, flag=True):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1106, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1094
 *         CHKERR( SVDCyclicSetExplicitMatrix(self.svd, tval) )
 * 
 *     def getCyclicExplicitMatrix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating if ``H(A) = [ 0 A ; A^T 0 ]`` is
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getCyclicExplicitMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1108
 *         return toBool(tval)
 * 
 *     def setLanczosOneSide(self, flag=True):             # <<<<<<<<<<<<<<
 *         """
 *         Indicate if the variant of the Lanczos method to be used is
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_123setLanczosOneSide(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_122setLanczosOneSide[] = "SVD.setLanczosOneSide(self, flag=True)\n\n        Indicate if the variant of the Lanczos method to be used is\n        one-sided or two-sided.\n\n        Parameters\n        ----------\n        flag: bool\n              True if the method is one-sided.\n\n        Notes\n        -----\n        By default, a two-sided variant is selected, which is\n        sometimes slightly more robust. However, the one-sided variant\n        is faster because it avoids the orthogonalization associated\n        to left singular vectors. It also saves the memory required\n        for storing such vectors.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_123setLanczosOneSide(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_flag = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setLanczosOneSide (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flag,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flag);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setLanczosOneSide") < 0)) __PYX_ERR(18, 1108, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_flag = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setLanczosOneSide", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 1108, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setLanczosOneSide", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_122setLanczosOneSide(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_flag);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_122setLanczosOneSide(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_flag) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setLanczosOneSide", 0);

  /* "SLEPc/SVD.pyx":1126
 *         for storing such vectors.
 *         """
 *         cdef PetscBool tval = asBool(flag)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDLanczosSetOneSide(self.svd, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_flag); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(18, 1126, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/SVD.pyx":1127
 *         """
 *         cdef PetscBool tval = asBool(flag)
 *         CHKERR( SVDLanczosSetOneSide(self.svd, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getLanczosOneSide(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDLanczosSetOneSide(__pyx_v_self->svd, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 1127, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1108
 *         return toBool(tval)
 * 
 *     def setLanczosOneSide(self, flag=True):             # <<<<<<<<<<<<<<
 *         """
 *         Indicate if the variant of the Lanczos method to be used is
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setLanczosOneSide", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1129
 *         CHKERR( SVDLanczosSetOneSide(self.svd, tval) )
 * 
 *     def getLanczosOneSide(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets if the variant of the Lanczos method to be used is
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_125getLanczosOneSide(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_124getLanczosOneSide[] = "SVD.getLanczosOneSide(self)\n\n        Gets if the variant of the Lanczos method to be used is\n        one-sided or two-sided.\n\n        Returns\n        -------\n        delayed: bool\n                 True if the method is one-sided.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_125getLanczosOneSide(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getLanczosOneSide (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getLanczosOneSide", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLanczosOneSide", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_124getLanczosOneSide(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_124getLanczosOneSide(struct PySlepcSVDObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getLanczosOneSide", 0);

  /* "SLEPc/SVD.pyx":1139
 *                  True if the method is one-sided.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( SVDLanczosGetOneSide(self.svd, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/SVD.pyx":1140
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDLanczosGetOneSide(self.svd, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDLanczosGetOneSide(__pyx_v_self->svd, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 1140, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1141
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDLanczosGetOneSide(self.svd, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setTRLanczosOneSide(self, flag=True):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1141, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1129
 *         CHKERR( SVDLanczosSetOneSide(self.svd, tval) )
 * 
 *     def getLanczosOneSide(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets if the variant of the Lanczos method to be used is
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getLanczosOneSide", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1143
 *         return toBool(tval)
 * 
 *     def setTRLanczosOneSide(self, flag=True):             # <<<<<<<<<<<<<<
 *         """
 *         Indicate if the variant of the thick-restart Lanczos method to
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_127setTRLanczosOneSide(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_126setTRLanczosOneSide[] = "SVD.setTRLanczosOneSide(self, flag=True)\n\n        Indicate if the variant of the thick-restart Lanczos method to\n        be used is one-sided or two-sided.\n\n        Parameters\n        ----------\n        flag: bool\n              True if the method is one-sided.\n\n        Notes\n        -----\n        By default, a two-sided variant is selected, which is\n        sometimes slightly more robust. However, the one-sided variant\n        is faster because it avoids the orthogonalization associated\n        to left singular vectors.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_127setTRLanczosOneSide(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_flag = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTRLanczosOneSide (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flag,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flag);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTRLanczosOneSide") < 0)) __PYX_ERR(18, 1143, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_flag = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTRLanczosOneSide", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 1143, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTRLanczosOneSide", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_126setTRLanczosOneSide(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_flag);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_126setTRLanczosOneSide(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_flag) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTRLanczosOneSide", 0);

  /* "SLEPc/SVD.pyx":1160
 *         to left singular vectors.
 *         """
 *         cdef PetscBool tval = asBool(flag)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDLanczosSetOneSide(self.svd, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_flag); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(18, 1160, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/SVD.pyx":1161
 *         """
 *         cdef PetscBool tval = asBool(flag)
 *         CHKERR( SVDLanczosSetOneSide(self.svd, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getTRLanczosOneSide(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDLanczosSetOneSide(__pyx_v_self->svd, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 1161, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1143
 *         return toBool(tval)
 * 
 *     def setTRLanczosOneSide(self, flag=True):             # <<<<<<<<<<<<<<
 *         """
 *         Indicate if the variant of the thick-restart Lanczos method to
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTRLanczosOneSide", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1163
 *         CHKERR( SVDLanczosSetOneSide(self.svd, tval) )
 * 
 *     def getTRLanczosOneSide(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets if the variant of the thick-restart Lanczos method to be
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_129getTRLanczosOneSide(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_128getTRLanczosOneSide[] = "SVD.getTRLanczosOneSide(self)\n\n        Gets if the variant of the thick-restart Lanczos method to be\n        used is one-sided or two-sided.\n\n        Returns\n        -------\n        delayed: bool\n                 True if the method is one-sided.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_129getTRLanczosOneSide(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTRLanczosOneSide (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTRLanczosOneSide", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTRLanczosOneSide", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_128getTRLanczosOneSide(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_128getTRLanczosOneSide(struct PySlepcSVDObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTRLanczosOneSide", 0);

  /* "SLEPc/SVD.pyx":1173
 *                  True if the method is one-sided.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( SVDTRLanczosGetOneSide(self.svd, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/SVD.pyx":1174
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDTRLanczosGetOneSide(self.svd, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDTRLanczosGetOneSide(__pyx_v_self->svd, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 1174, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1175
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDTRLanczosGetOneSide(self.svd, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setTRLanczosGBidiag(self, bidiag):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1175, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1163
 *         CHKERR( SVDLanczosSetOneSide(self.svd, tval) )
 * 
 *     def getTRLanczosOneSide(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets if the variant of the thick-restart Lanczos method to be
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getTRLanczosOneSide", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1177
 *         return toBool(tval)
 * 
 *     def setTRLanczosGBidiag(self, bidiag):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the bidiagonalization choice to use in the GSVD
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_131setTRLanczosGBidiag(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_130setTRLanczosGBidiag[] = "SVD.setTRLanczosGBidiag(self, bidiag)\n\n        Sets the bidiagonalization choice to use in the GSVD\n        TRLanczos solver.\n\n        Parameters\n        ----------\n        bidiag: `SVD.TRLanczosGBidiag` enumerate\n               The bidiagonalization choice.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_131setTRLanczosGBidiag(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_bidiag = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTRLanczosGBidiag (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bidiag,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bidiag)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTRLanczosGBidiag") < 0)) __PYX_ERR(18, 1177, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_bidiag = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTRLanczosGBidiag", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 1177, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTRLanczosGBidiag", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_130setTRLanczosGBidiag(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_bidiag);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_130setTRLanczosGBidiag(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_bidiag) {
  SVDTRLanczosGBidiag __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  SVDTRLanczosGBidiag __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTRLanczosGBidiag", 0);

  /* "SLEPc/SVD.pyx":1187
 *                The bidiagonalization choice.
 *         """
 *         cdef SlepcSVDTRLanczosGBidiag val = bidiag             # <<<<<<<<<<<<<<
 *         CHKERR( SVDTRLanczosSetGBidiag(self.svd, val) )
 * 
 */
  __pyx_t_1 = ((SVDTRLanczosGBidiag)__Pyx_PyInt_As_SVDTRLanczosGBidiag(__pyx_v_bidiag)); if (unlikely(PyErr_Occurred())) __PYX_ERR(18, 1187, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/SVD.pyx":1188
 *         """
 *         cdef SlepcSVDTRLanczosGBidiag val = bidiag
 *         CHKERR( SVDTRLanczosSetGBidiag(self.svd, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getTRLanczosGBidiag(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDTRLanczosSetGBidiag(__pyx_v_self->svd, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 1188, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1177
 *         return toBool(tval)
 * 
 *     def setTRLanczosGBidiag(self, bidiag):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the bidiagonalization choice to use in the GSVD
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTRLanczosGBidiag", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1190
 *         CHKERR( SVDTRLanczosSetGBidiag(self.svd, val) )
 * 
 *     def getTRLanczosGBidiag(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns bidiagonalization choice used in the GSVD
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_133getTRLanczosGBidiag(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_132getTRLanczosGBidiag[] = "SVD.getTRLanczosGBidiag(self)\n\n        Returns bidiagonalization choice used in the GSVD\n        TRLanczos solver.\n\n        Returns\n        -------\n        bidiag: `SVD.TRLanczosGBidiag` enumerate\n               The bidiagonalization choice.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_133getTRLanczosGBidiag(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTRLanczosGBidiag (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTRLanczosGBidiag", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTRLanczosGBidiag", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_132getTRLanczosGBidiag(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_132getTRLanczosGBidiag(struct PySlepcSVDObject *__pyx_v_self) {
  SVDTRLanczosGBidiag __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTRLanczosGBidiag", 0);

  /* "SLEPc/SVD.pyx":1200
 *                The bidiagonalization choice.
 *         """
 *         cdef SlepcSVDTRLanczosGBidiag val = SVD_TRLANCZOS_GBIDIAG_LOWER             # <<<<<<<<<<<<<<
 *         CHKERR( SVDTRLanczosGetGBidiag(self.svd, &val) )
 *         return val
 */
  __pyx_v_val = SVD_TRLANCZOS_GBIDIAG_LOWER;

  /* "SLEPc/SVD.pyx":1201
 *         """
 *         cdef SlepcSVDTRLanczosGBidiag val = SVD_TRLANCZOS_GBIDIAG_LOWER
 *         CHKERR( SVDTRLanczosGetGBidiag(self.svd, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDTRLanczosGetGBidiag(__pyx_v_self->svd, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 1201, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1202
 *         cdef SlepcSVDTRLanczosGBidiag val = SVD_TRLANCZOS_GBIDIAG_LOWER
 *         CHKERR( SVDTRLanczosGetGBidiag(self.svd, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setTRLanczosRestart(self, keep):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_SVDTRLanczosGBidiag(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1190
 *         CHKERR( SVDTRLanczosSetGBidiag(self.svd, val) )
 * 
 *     def getTRLanczosGBidiag(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns bidiagonalization choice used in the GSVD
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getTRLanczosGBidiag", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1204
 *         return val
 * 
 *     def setTRLanczosRestart(self, keep):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the restart parameter for the thick-restart Lanczos method, in
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_135setTRLanczosRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_134setTRLanczosRestart[] = "SVD.setTRLanczosRestart(self, keep)\n\n        Sets the restart parameter for the thick-restart Lanczos method, in\n        particular the proportion of basis vectors that must be kept\n        after restart.\n\n        Parameters\n        ----------\n        keep: float\n              The number of vectors to be kept at restart.\n\n        Notes\n        -----\n        Allowed values are in the range [0.1,0.9]. The default is 0.5.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_135setTRLanczosRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_keep = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTRLanczosRestart (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_keep,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_keep)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTRLanczosRestart") < 0)) __PYX_ERR(18, 1204, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_keep = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTRLanczosRestart", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 1204, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTRLanczosRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_134setTRLanczosRestart(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_keep);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_134setTRLanczosRestart(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_keep) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTRLanczosRestart", 0);

  /* "SLEPc/SVD.pyx":1219
 *         Allowed values are in the range [0.1,0.9]. The default is 0.5.
 *         """
 *         cdef PetscReal val = asReal(keep)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDTRLanczosSetRestart(self.svd, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_keep); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(18, 1219, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/SVD.pyx":1220
 *         """
 *         cdef PetscReal val = asReal(keep)
 *         CHKERR( SVDTRLanczosSetRestart(self.svd, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getTRLanczosRestart(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDTRLanczosSetRestart(__pyx_v_self->svd, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 1220, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1204
 *         return val
 * 
 *     def setTRLanczosRestart(self, keep):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the restart parameter for the thick-restart Lanczos method, in
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTRLanczosRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1222
 *         CHKERR( SVDTRLanczosSetRestart(self.svd, val) )
 * 
 *     def getTRLanczosRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the restart parameter used in the thick-restart Lanczos method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_137getTRLanczosRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_136getTRLanczosRestart[] = "SVD.getTRLanczosRestart(self)\n\n        Gets the restart parameter used in the thick-restart Lanczos method.\n\n        Returns\n        -------\n        keep: float\n              The number of vectors to be kept at restart.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_137getTRLanczosRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTRLanczosRestart (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTRLanczosRestart", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTRLanczosRestart", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_136getTRLanczosRestart(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_136getTRLanczosRestart(struct PySlepcSVDObject *__pyx_v_self) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTRLanczosRestart", 0);

  /* "SLEPc/SVD.pyx":1231
 *               The number of vectors to be kept at restart.
 *         """
 *         cdef PetscReal val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( SVDTRLanczosGetRestart(self.svd, &val) )
 *         return toReal(val)
 */
  __pyx_v_val = 0.0;

  /* "SLEPc/SVD.pyx":1232
 *         """
 *         cdef PetscReal val = 0
 *         CHKERR( SVDTRLanczosGetRestart(self.svd, &val) )             # <<<<<<<<<<<<<<
 *         return toReal(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDTRLanczosGetRestart(__pyx_v_self->svd, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 1232, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1233
 *         cdef PetscReal val = 0
 *         CHKERR( SVDTRLanczosGetRestart(self.svd, &val) )
 *         return toReal(val)             # <<<<<<<<<<<<<<
 * 
 *     def setTRLanczosLocking(self, lock):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1233, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1222
 *         CHKERR( SVDTRLanczosSetRestart(self.svd, val) )
 * 
 *     def getTRLanczosRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the restart parameter used in the thick-restart Lanczos method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getTRLanczosRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1235
 *         return toReal(val)
 * 
 *     def setTRLanczosLocking(self, lock):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between locking and non-locking variants of the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_139setTRLanczosLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_138setTRLanczosLocking[] = "SVD.setTRLanczosLocking(self, lock)\n\n        Choose between locking and non-locking variants of the\n        thick-restart Lanczos method.\n\n        Parameters\n        ----------\n        lock: bool\n              True if the locking variant must be selected.\n\n        Notes\n        -----\n        The default is to lock converged singular triplets when the method restarts.\n        This behaviour can be changed so that all directions are kept in the\n        working subspace even if already converged to working accuracy (the\n        non-locking variant).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_139setTRLanczosLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_lock = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTRLanczosLocking (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lock,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lock)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTRLanczosLocking") < 0)) __PYX_ERR(18, 1235, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_lock = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTRLanczosLocking", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 1235, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTRLanczosLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_138setTRLanczosLocking(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_lock);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_138setTRLanczosLocking(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_lock) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTRLanczosLocking", 0);

  /* "SLEPc/SVD.pyx":1252
 *         non-locking variant).
 *         """
 *         cdef PetscBool val = asBool(lock)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDTRLanczosSetLocking(self.svd, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_lock); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(18, 1252, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/SVD.pyx":1253
 *         """
 *         cdef PetscBool val = asBool(lock)
 *         CHKERR( SVDTRLanczosSetLocking(self.svd, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getTRLanczosLocking(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDTRLanczosSetLocking(__pyx_v_self->svd, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 1253, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1235
 *         return toReal(val)
 * 
 *     def setTRLanczosLocking(self, lock):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between locking and non-locking variants of the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTRLanczosLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1255
 *         CHKERR( SVDTRLanczosSetLocking(self.svd, val) )
 * 
 *     def getTRLanczosLocking(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the locking flag used in the thick-restart Lanczos method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_141getTRLanczosLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_140getTRLanczosLocking[] = "SVD.getTRLanczosLocking(self)\n\n        Gets the locking flag used in the thick-restart Lanczos method.\n\n        Returns\n        -------\n        lock: bool\n              The locking flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_141getTRLanczosLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTRLanczosLocking (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTRLanczosLocking", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTRLanczosLocking", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_140getTRLanczosLocking(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_140getTRLanczosLocking(struct PySlepcSVDObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTRLanczosLocking", 0);

  /* "SLEPc/SVD.pyx":1264
 *               The locking flag.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( SVDTRLanczosGetLocking(self.svd, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/SVD.pyx":1265
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDTRLanczosGetLocking(self.svd, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDTRLanczosGetLocking(__pyx_v_self->svd, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 1265, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1266
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDTRLanczosGetLocking(self.svd, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setTRLanczosKSP(self, KSP ksp):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1266, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1255
 *         CHKERR( SVDTRLanczosSetLocking(self.svd, val) )
 * 
 *     def getTRLanczosLocking(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the locking flag used in the thick-restart Lanczos method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getTRLanczosLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1268
 *         return toBool(tval)
 * 
 *     def setTRLanczosKSP(self, KSP ksp):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a linear solver object to the SVD solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_143setTRLanczosKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_142setTRLanczosKSP[] = "SVD.setTRLanczosKSP(self, KSP ksp)\n\n        Associate a linear solver object to the SVD solver.\n\n        Parameters\n        ----------\n        ksp: `KSP`\n             The linear solver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_143setTRLanczosKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscKSPObject *__pyx_v_ksp = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTRLanczosKSP (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ksp,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ksp)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTRLanczosKSP") < 0)) __PYX_ERR(18, 1268, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_ksp = ((struct PyPetscKSPObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTRLanczosKSP", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 1268, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTRLanczosKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ksp), __pyx_ptype_8petsc4py_5PETSc_KSP, 0, "ksp", 0))) __PYX_ERR(18, 1268, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_142setTRLanczosKSP(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_ksp);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_142setTRLanczosKSP(struct PySlepcSVDObject *__pyx_v_self, struct PyPetscKSPObject *__pyx_v_ksp) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTRLanczosKSP", 0);

  /* "SLEPc/SVD.pyx":1277
 *              The linear solver object.
 *         """
 *         CHKERR( SVDTRLanczosSetKSP(self.svd, ksp.ksp) )             # <<<<<<<<<<<<<<
 * 
 *     def getTRLanczosKSP(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDTRLanczosSetKSP(__pyx_v_self->svd, __pyx_v_ksp->ksp)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 1277, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1268
 *         return toBool(tval)
 * 
 *     def setTRLanczosKSP(self, KSP ksp):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a linear solver object to the SVD solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTRLanczosKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1279
 *         CHKERR( SVDTRLanczosSetKSP(self.svd, ksp.ksp) )
 * 
 *     def getTRLanczosKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the linear solver object associated with the SVD solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_145getTRLanczosKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_144getTRLanczosKSP[] = "SVD.getTRLanczosKSP(self)\n\n        Retrieve the linear solver object associated with the SVD solver.\n\n        Returns\n        -------\n        ksp: `KSP`\n             The linear solver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_145getTRLanczosKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTRLanczosKSP (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTRLanczosKSP", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTRLanczosKSP", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_144getTRLanczosKSP(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_144getTRLanczosKSP(struct PySlepcSVDObject *__pyx_v_self) {
  struct PyPetscKSPObject *__pyx_v_ksp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTRLanczosKSP", 0);

  /* "SLEPc/SVD.pyx":1288
 *              The linear solver object.
 *         """
 *         cdef KSP ksp = KSP()             # <<<<<<<<<<<<<<
 *         CHKERR( SVDTRLanczosGetKSP(self.svd, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_KSP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1288, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ksp = ((struct PyPetscKSPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":1289
 *         """
 *         cdef KSP ksp = KSP()
 *         CHKERR( SVDTRLanczosGetKSP(self.svd, &ksp.ksp) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(ksp.obj)
 *         return ksp
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDTRLanczosGetKSP(__pyx_v_self->svd, (&__pyx_v_ksp->ksp))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 1289, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1290
 *         cdef KSP ksp = KSP()
 *         CHKERR( SVDTRLanczosGetKSP(self.svd, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)             # <<<<<<<<<<<<<<
 *         return ksp
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ksp->__pyx_base.obj));

  /* "SLEPc/SVD.pyx":1291
 *         CHKERR( SVDTRLanczosGetKSP(self.svd, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 *         return ksp             # <<<<<<<<<<<<<<
 * 
 *     def setTRLanczosExplicitMatrix(self, flag=True):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ksp));
  __pyx_r = ((PyObject *)__pyx_v_ksp);
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1279
 *         CHKERR( SVDTRLanczosSetKSP(self.svd, ksp.ksp) )
 * 
 *     def getTRLanczosKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the linear solver object associated with the SVD solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getTRLanczosKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ksp);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1293
 *         return ksp
 * 
 *     def setTRLanczosExplicitMatrix(self, flag=True):             # <<<<<<<<<<<<<<
 *         """
 *         Indicate if the matrix ``Z=[A;B]`` must be built explicitly.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_147setTRLanczosExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_146setTRLanczosExplicitMatrix[] = "SVD.setTRLanczosExplicitMatrix(self, flag=True)\n\n        Indicate if the matrix ``Z=[A;B]`` must be built explicitly.\n\n        Parameters\n        ----------\n        flag: bool\n              True if ``Z=[A;B]`` is built explicitly.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_147setTRLanczosExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_flag = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTRLanczosExplicitMatrix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flag,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flag);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTRLanczosExplicitMatrix") < 0)) __PYX_ERR(18, 1293, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_flag = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTRLanczosExplicitMatrix", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 1293, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTRLanczosExplicitMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_146setTRLanczosExplicitMatrix(((struct PySlepcSVDObject *)__pyx_v_self), __pyx_v_flag);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_146setTRLanczosExplicitMatrix(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_flag) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTRLanczosExplicitMatrix", 0);

  /* "SLEPc/SVD.pyx":1302
 *               True if ``Z=[A;B]`` is built explicitly.
 *         """
 *         cdef PetscBool tval = asBool(flag)             # <<<<<<<<<<<<<<
 *         CHKERR( SVDTRLanczosSetExplicitMatrix(self.svd, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_flag); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(18, 1302, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/SVD.pyx":1303
 *         """
 *         cdef PetscBool tval = asBool(flag)
 *         CHKERR( SVDTRLanczosSetExplicitMatrix(self.svd, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getTRLanczosExplicitMatrix(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDTRLanczosSetExplicitMatrix(__pyx_v_self->svd, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(18, 1303, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1293
 *         return ksp
 * 
 *     def setTRLanczosExplicitMatrix(self, flag=True):             # <<<<<<<<<<<<<<
 *         """
 *         Indicate if the matrix ``Z=[A;B]`` must be built explicitly.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.setTRLanczosExplicitMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1305
 *         CHKERR( SVDTRLanczosSetExplicitMatrix(self.svd, tval) )
 * 
 *     def getTRLanczosExplicitMatrix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating if ``Z=[A;B]`` is built explicitly.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_149getTRLanczosExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3SVD_148getTRLanczosExplicitMatrix[] = "SVD.getTRLanczosExplicitMatrix(self)\n\n        Returns the flag indicating if ``Z=[A;B]`` is built explicitly.\n\n        Returns\n        -------\n        flag: bool\n              True if ``Z=[A;B]`` is built explicitly.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_149getTRLanczosExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTRLanczosExplicitMatrix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTRLanczosExplicitMatrix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTRLanczosExplicitMatrix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_148getTRLanczosExplicitMatrix(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_148getTRLanczosExplicitMatrix(struct PySlepcSVDObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTRLanczosExplicitMatrix", 0);

  /* "SLEPc/SVD.pyx":1314
 *               True if ``Z=[A;B]`` is built explicitly.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( SVDTRLanczosGetExplicitMatrix(self.svd, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/SVD.pyx":1315
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDTRLanczosGetExplicitMatrix(self.svd, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SVDTRLanczosGetExplicitMatrix(__pyx_v_self->svd, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(18, 1315, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1316
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( SVDTRLanczosGetExplicitMatrix(self.svd, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     setOperator = setOperators  # backward compatibility
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1316, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1305
 *         CHKERR( SVDTRLanczosSetExplicitMatrix(self.svd, tval) )
 * 
 *     def getTRLanczosExplicitMatrix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating if ``Z=[A;B]`` is built explicitly.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.getTRLanczosExplicitMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1323
 * 
 *     property problem_type:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getProblemType()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_12problem_type_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_12problem_type_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_12problem_type___get__(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_12problem_type___get__(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/SVD.pyx":1324
 *     property problem_type:
 *         def __get__(self):
 *             return self.getProblemType()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setProblemType(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getProblemType); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1324, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1324, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1323
 * 
 *     property problem_type:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getProblemType()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.problem_type.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1325
 *         def __get__(self):
 *             return self.getProblemType()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setProblemType(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_12problem_type_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_12problem_type_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_12problem_type_2__set__(((struct PySlepcSVDObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3SVD_12problem_type_2__set__(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/SVD.pyx":1326
 *             return self.getProblemType()
 *         def __set__(self, value):
 *             self.setProblemType(value)             # <<<<<<<<<<<<<<
 * 
 *     property transpose_mode:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setProblemType); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1326, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1326, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":1325
 *         def __get__(self):
 *             return self.getProblemType()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setProblemType(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.problem_type.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1329
 * 
 *     property transpose_mode:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTransposeMode()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_14transpose_mode_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_14transpose_mode_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_14transpose_mode___get__(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_14transpose_mode___get__(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/SVD.pyx":1330
 *     property transpose_mode:
 *         def __get__(self):
 *             return self.getTransposeMode()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTransposeMode(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTransposeMode); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1330, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1329
 * 
 *     property transpose_mode:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTransposeMode()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.transpose_mode.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1331
 *         def __get__(self):
 *             return self.getTransposeMode()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTransposeMode(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_14transpose_mode_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_14transpose_mode_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_14transpose_mode_2__set__(((struct PySlepcSVDObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3SVD_14transpose_mode_2__set__(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/SVD.pyx":1332
 *             return self.getTransposeMode()
 *         def __set__(self, value):
 *             self.setTransposeMode(value)             # <<<<<<<<<<<<<<
 * 
 *     property which:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTransposeMode); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1332, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1332, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":1331
 *         def __get__(self):
 *             return self.getTransposeMode()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTransposeMode(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.transpose_mode.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1335
 * 
 *     property which:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getWhichSingularTriplets()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_5which_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_5which_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_5which___get__(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_5which___get__(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/SVD.pyx":1336
 *     property which:
 *         def __get__(self):
 *             return self.getWhichSingularTriplets()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setWhichSingularTriplets(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getWhichSingularTriplets); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1336, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1336, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1335
 * 
 *     property which:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getWhichSingularTriplets()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.which.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1337
 *         def __get__(self):
 *             return self.getWhichSingularTriplets()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setWhichSingularTriplets(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_5which_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_5which_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_5which_2__set__(((struct PySlepcSVDObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3SVD_5which_2__set__(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/SVD.pyx":1338
 *             return self.getWhichSingularTriplets()
 *         def __set__(self, value):
 *             self.setWhichSingularTriplets(value)             # <<<<<<<<<<<<<<
 * 
 *     property tol:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setWhichSingularTriplets); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1338, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1338, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":1337
 *         def __get__(self):
 *             return self.getWhichSingularTriplets()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setWhichSingularTriplets(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.which.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1341
 * 
 *     property tol:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_3tol_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_3tol_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_3tol___get__(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_3tol___get__(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/SVD.pyx":1342
 *     property tol:
 *         def __get__(self):
 *             return self.getTolerances()[0]             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTolerances(tol=value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTolerances); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1342, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1342, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1342, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1341
 * 
 *     property tol:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.tol.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1343
 *         def __get__(self):
 *             return self.getTolerances()[0]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(tol=value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_3tol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_3tol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_3tol_2__set__(((struct PySlepcSVDObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3SVD_3tol_2__set__(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/SVD.pyx":1344
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 *             self.setTolerances(tol=value)             # <<<<<<<<<<<<<<
 * 
 *     property max_it:
 */
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTolerances); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1344, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1344, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_tol, __pyx_v_value) < 0) __PYX_ERR(18, 1344, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 1344, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/SVD.pyx":1343
 *         def __get__(self):
 *             return self.getTolerances()[0]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(tol=value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.tol.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1347
 * 
 *     property max_it:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_6max_it_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_6max_it_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_6max_it___get__(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_6max_it___get__(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/SVD.pyx":1348
 *     property max_it:
 *         def __get__(self):
 *             return self.getTolerances()[1]             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTolerances(max_it=value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTolerances); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1347
 * 
 *     property max_it:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.max_it.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1349
 *         def __get__(self):
 *             return self.getTolerances()[1]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(max_it=value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_6max_it_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_6max_it_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_6max_it_2__set__(((struct PySlepcSVDObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3SVD_6max_it_2__set__(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/SVD.pyx":1350
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 *             self.setTolerances(max_it=value)             # <<<<<<<<<<<<<<
 * 
 *     property track_all:
 */
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTolerances); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_it, __pyx_v_value) < 0) __PYX_ERR(18, 1350, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 1350, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/SVD.pyx":1349
 *         def __get__(self):
 *             return self.getTolerances()[1]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(max_it=value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.max_it.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1353
 * 
 *     property track_all:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTrackAll()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_9track_all_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_9track_all_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_9track_all___get__(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_9track_all___get__(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/SVD.pyx":1354
 *     property track_all:
 *         def __get__(self):
 *             return self.getTrackAll()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTrackAll(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTrackAll); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1354, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1354, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1353
 * 
 *     property track_all:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTrackAll()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.track_all.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1355
 *         def __get__(self):
 *             return self.getTrackAll()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTrackAll(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_9track_all_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_9track_all_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_9track_all_2__set__(((struct PySlepcSVDObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3SVD_9track_all_2__set__(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/SVD.pyx":1356
 *             return self.getTrackAll()
 *         def __set__(self, value):
 *             self.setTrackAll(value)             # <<<<<<<<<<<<<<
 * 
 *     property ds:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTrackAll); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1356, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1356, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":1355
 *         def __get__(self):
 *             return self.getTrackAll()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTrackAll(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.track_all.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1359
 * 
 *     property ds:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getDS()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_2ds_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3SVD_2ds_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_2ds___get__(((struct PySlepcSVDObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3SVD_2ds___get__(struct PySlepcSVDObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/SVD.pyx":1360
 *     property ds:
 *         def __get__(self):
 *             return self.getDS()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setDS(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getDS); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1360, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1360, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/SVD.pyx":1359
 * 
 *     property ds:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getDS()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.ds.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SVD.pyx":1361
 *         def __get__(self):
 *             return self.getDS()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setDS(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_2ds_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3SVD_2ds_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3SVD_2ds_2__set__(((struct PySlepcSVDObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3SVD_2ds_2__set__(struct PySlepcSVDObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/SVD.pyx":1362
 *             return self.getDS()
 *         def __set__(self, value):
 *             self.setDS(value)             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setDS); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1362, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 1362, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/SVD.pyx":1361
 *         def __get__(self):
 *             return self.getDS()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setDS(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.SVD.ds.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":237
 *     CISSExtraction  = PEPCISSExtraction
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.pep
 *         self.pep = NULL
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP___cinit__(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3PEP___cinit__(struct PySlepcPEPObject *__pyx_v_self) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "SLEPc/PEP.pyx":238
 * 
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.pep             # <<<<<<<<<<<<<<
 *         self.pep = NULL
 * 
 */
  __pyx_v_self->__pyx_base.obj = ((PetscObject *)(&__pyx_v_self->pep));

  /* "SLEPc/PEP.pyx":239
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.pep
 *         self.pep = NULL             # <<<<<<<<<<<<<<
 * 
 *     def view(self, Viewer viewer=None):
 */
  __pyx_v_self->pep = NULL;

  /* "SLEPc/PEP.pyx":237
 *     CISSExtraction  = PEPCISSExtraction
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.pep
 *         self.pep = NULL
 */

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":241
 *         self.pep = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the PEP data structure.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_2view[] = "PEP.view(self, Viewer viewer=None)\n\n        Prints the PEP data structure.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional.\n            Visualization context; if not provided, the standard\n            output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("view (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "view") < 0)) __PYX_ERR(19, 241, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("view", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 241, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(19, 241, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_2view(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_2view(struct PySlepcPEPObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("view", 0);

  /* "SLEPc/PEP.pyx":251
 *             output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPView(self.pep, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/PEP.pyx":252
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( PEPView(self.pep, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def destroy(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPView(__pyx_v_self->pep, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 252, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":241
 *         self.pep = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the PEP data structure.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":254
 *         CHKERR( PEPView(self.pep, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the PEP object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_4destroy[] = "PEP.destroy(self)\n\n        Destroys the PEP object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("destroy (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("destroy", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "destroy", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_4destroy(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_4destroy(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("destroy", 0);

  /* "SLEPc/PEP.pyx":258
 *         Destroys the PEP object.
 *         """
 *         CHKERR( PEPDestroy(&self.pep) )             # <<<<<<<<<<<<<<
 *         self.pep = NULL
 *         return self
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPDestroy((&__pyx_v_self->pep))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 258, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":259
 *         """
 *         CHKERR( PEPDestroy(&self.pep) )
 *         self.pep = NULL             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  __pyx_v_self->pep = NULL;

  /* "SLEPc/PEP.pyx":260
 *         CHKERR( PEPDestroy(&self.pep) )
 *         self.pep = NULL
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def reset(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":254
 *         CHKERR( PEPView(self.pep, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the PEP object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.destroy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":262
 *         return self
 * 
 *     def reset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Resets the PEP object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_7reset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_6reset[] = "PEP.reset(self)\n\n        Resets the PEP object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_7reset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("reset (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("reset", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "reset", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_6reset(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_6reset(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("reset", 0);

  /* "SLEPc/PEP.pyx":266
 *         Resets the PEP object.
 *         """
 *         CHKERR( PEPReset(self.pep) )             # <<<<<<<<<<<<<<
 * 
 *     def create(self, comm=None):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPReset(__pyx_v_self->pep)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 266, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":262
 *         return self
 * 
 *     def reset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Resets the PEP object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.reset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":268
 *         CHKERR( PEPReset(self.pep) )
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the PEP object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_9create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_8create[] = "PEP.create(self, comm=None)\n\n        Creates the PEP object.\n\n        Parameters\n        ----------\n        comm: Comm, optional.\n            MPI communicator. If not provided, it defaults to all\n            processes.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_9create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comm = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comm,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comm);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create") < 0)) __PYX_ERR(19, 268, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_comm = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("create", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 268, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_8create(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_comm);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_8create(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_comm) {
  MPI_Comm __pyx_v_ccomm;
  PEP __pyx_v_newpep;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  MPI_Comm __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("create", 0);

  /* "SLEPc/PEP.pyx":278
 *             processes.
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())             # <<<<<<<<<<<<<<
 *         cdef SlepcPEP newpep = NULL
 *         CHKERR( PEPCreate(ccomm, &newpep) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_def_Comm(__pyx_v_comm, __pyx_f_8slepc4py_5SLEPc_SLEPC_COMM_DEFAULT()); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 278, __pyx_L1_error)
  __pyx_v_ccomm = __pyx_t_1;

  /* "SLEPc/PEP.pyx":279
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcPEP newpep = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( PEPCreate(ccomm, &newpep) )
 *         SlepcCLEAR(self.obj); self.pep = newpep
 */
  __pyx_v_newpep = NULL;

  /* "SLEPc/PEP.pyx":280
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcPEP newpep = NULL
 *         CHKERR( PEPCreate(ccomm, &newpep) )             # <<<<<<<<<<<<<<
 *         SlepcCLEAR(self.obj); self.pep = newpep
 *         return self
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPCreate(__pyx_v_ccomm, (&__pyx_v_newpep))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 280, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":281
 *         cdef SlepcPEP newpep = NULL
 *         CHKERR( PEPCreate(ccomm, &newpep) )
 *         SlepcCLEAR(self.obj); self.pep = newpep             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_SlepcCLEAR(__pyx_v_self->__pyx_base.obj));
  __pyx_v_self->pep = __pyx_v_newpep;

  /* "SLEPc/PEP.pyx":282
 *         CHKERR( PEPCreate(ccomm, &newpep) )
 *         SlepcCLEAR(self.obj); self.pep = newpep
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def setType(self, pep_type):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":268
 *         CHKERR( PEPReset(self.pep) )
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the PEP object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":284
 *         return self
 * 
 *     def setType(self, pep_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the particular solver to be used in the PEP object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_11setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_10setType[] = "PEP.setType(self, pep_type)\n\n        Selects the particular solver to be used in the PEP object.\n\n        Parameters\n        ----------\n        pep_type: `PEP.Type` enumerate\n            The solver to be used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_11setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_pep_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pep_type,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pep_type)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setType") < 0)) __PYX_ERR(19, 284, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_pep_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 284, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_10setType(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_pep_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_10setType(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_pep_type) {
  const char* __pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setType", 0);
  __Pyx_INCREF(__pyx_v_pep_type);

  /* "SLEPc/PEP.pyx":293
 *             The solver to be used.
 *         """
 *         cdef SlepcPEPType cval = NULL             # <<<<<<<<<<<<<<
 *         pep_type = str2bytes(pep_type, &cval)
 *         CHKERR( PEPSetType(self.pep, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/PEP.pyx":294
 *         """
 *         cdef SlepcPEPType cval = NULL
 *         pep_type = str2bytes(pep_type, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetType(self.pep, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_pep_type, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 294, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_pep_type, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":295
 *         cdef SlepcPEPType cval = NULL
 *         pep_type = str2bytes(pep_type, &cval)
 *         CHKERR( PEPSetType(self.pep, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getType(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetType(__pyx_v_self->pep, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 295, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":284
 *         return self
 * 
 *     def setType(self, pep_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the particular solver to be used in the PEP object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_pep_type);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":297
 *         CHKERR( PEPSetType(self.pep, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the PEP type of this object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_13getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_12getType[] = "PEP.getType(self)\n\n        Gets the PEP type of this object.\n\n        Returns\n        -------\n        type: `PEP.Type` enumerate\n            The solver currently being used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_13getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_12getType(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_12getType(struct PySlepcPEPObject *__pyx_v_self) {
  const char* __pyx_v_pep_type;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getType", 0);

  /* "SLEPc/PEP.pyx":306
 *             The solver currently being used.
 *         """
 *         cdef SlepcPEPType pep_type = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetType(self.pep, &pep_type) )
 *         return bytes2str(pep_type)
 */
  __pyx_v_pep_type = NULL;

  /* "SLEPc/PEP.pyx":307
 *         """
 *         cdef SlepcPEPType pep_type = NULL
 *         CHKERR( PEPGetType(self.pep, &pep_type) )             # <<<<<<<<<<<<<<
 *         return bytes2str(pep_type)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetType(__pyx_v_self->pep, (&__pyx_v_pep_type))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 307, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":308
 *         cdef SlepcPEPType pep_type = NULL
 *         CHKERR( PEPGetType(self.pep, &pep_type) )
 *         return bytes2str(pep_type)             # <<<<<<<<<<<<<<
 * 
 *     def getOptionsPrefix(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_pep_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 308, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":297
 *         CHKERR( PEPSetType(self.pep, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the PEP type of this object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":310
 *         return bytes2str(pep_type)
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all PEP options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_15getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_14getOptionsPrefix[] = "PEP.getOptionsPrefix(self)\n\n        Gets the prefix used for searching for all PEP options in the\n        database.\n\n        Returns\n        -------\n        prefix: string\n            The prefix string set for this PEP object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_15getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOptionsPrefix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOptionsPrefix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOptionsPrefix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_14getOptionsPrefix(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_14getOptionsPrefix(struct PySlepcPEPObject *__pyx_v_self) {
  const char *__pyx_v_prefix;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOptionsPrefix", 0);

  /* "SLEPc/PEP.pyx":320
 *             The prefix string set for this PEP object.
 *         """
 *         cdef const_char *prefix = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetOptionsPrefix(self.pep, &prefix) )
 *         return bytes2str(prefix)
 */
  __pyx_v_prefix = NULL;

  /* "SLEPc/PEP.pyx":321
 *         """
 *         cdef const_char *prefix = NULL
 *         CHKERR( PEPGetOptionsPrefix(self.pep, &prefix) )             # <<<<<<<<<<<<<<
 *         return bytes2str(prefix)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetOptionsPrefix(__pyx_v_self->pep, (&__pyx_v_prefix))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 321, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":322
 *         cdef const_char *prefix = NULL
 *         CHKERR( PEPGetOptionsPrefix(self.pep, &prefix) )
 *         return bytes2str(prefix)             # <<<<<<<<<<<<<<
 * 
 *     def setOptionsPrefix(self, prefix):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_prefix); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 322, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":310
 *         return bytes2str(pep_type)
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all PEP options in the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":324
 *         return bytes2str(prefix)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all PEP options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_17setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_16setOptionsPrefix[] = "PEP.setOptionsPrefix(self, prefix)\n\n        Sets the prefix used for searching for all PEP options in the\n        database.\n\n        Parameters\n        ----------\n        prefix: string\n            The prefix string to prepend to all PEP option requests.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_17setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOptionsPrefix") < 0)) __PYX_ERR(19, 324, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 324, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_16setOptionsPrefix(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_16setOptionsPrefix(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/PEP.pyx":334
 *             The prefix string to prepend to all PEP option requests.
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( PEPSetOptionsPrefix(self.pep, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/PEP.pyx":335
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetOptionsPrefix(self.pep, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 335, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":336
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( PEPSetOptionsPrefix(self.pep, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def appendOptionsPrefix(self, prefix):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetOptionsPrefix(__pyx_v_self->pep, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 336, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":324
 *         return bytes2str(prefix)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all PEP options in the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":338
 *         CHKERR( PEPSetOptionsPrefix(self.pep, cval) )
 * 
 *     def appendOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Appends to the prefix used for searching for all PEP options
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_19appendOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_18appendOptionsPrefix[] = "PEP.appendOptionsPrefix(self, prefix)\n\n        Appends to the prefix used for searching for all PEP options\n        in the database.\n\n        Parameters\n        ----------\n        prefix: string\n            The prefix string to prepend to all PEP option requests.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_19appendOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("appendOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "appendOptionsPrefix") < 0)) __PYX_ERR(19, 338, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("appendOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 338, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.appendOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_18appendOptionsPrefix(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_18appendOptionsPrefix(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("appendOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/PEP.pyx":348
 *             The prefix string to prepend to all PEP option requests.
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( PEPAppendOptionsPrefix(self.pep, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/PEP.pyx":349
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPAppendOptionsPrefix(self.pep, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":350
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( PEPAppendOptionsPrefix(self.pep, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def setFromOptions(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPAppendOptionsPrefix(__pyx_v_self->pep, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 350, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":338
 *         CHKERR( PEPSetOptionsPrefix(self.pep, cval) )
 * 
 *     def appendOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Appends to the prefix used for searching for all PEP options
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.appendOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":352
 *         CHKERR( PEPAppendOptionsPrefix(self.pep, cval) )
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets PEP options from the options database. This routine must
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_21setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_20setFromOptions[] = "PEP.setFromOptions(self)\n\n        Sets PEP options from the options database. This routine must\n        be called before `setUp()` if the user is to be allowed to set\n        the solver type.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_21setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFromOptions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setFromOptions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setFromOptions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_20setFromOptions(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_20setFromOptions(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFromOptions", 0);

  /* "SLEPc/PEP.pyx":358
 *         the solver type.
 *         """
 *         CHKERR( PEPSetFromOptions(self.pep) )             # <<<<<<<<<<<<<<
 * 
 *     def getBasis(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetFromOptions(__pyx_v_self->pep)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 358, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":352
 *         CHKERR( PEPAppendOptionsPrefix(self.pep, cval) )
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets PEP options from the options database. This routine must
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setFromOptions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":360
 *         CHKERR( PEPSetFromOptions(self.pep) )
 * 
 *     def getBasis(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the type of polynomial basis used to
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_23getBasis(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_22getBasis[] = "PEP.getBasis(self)\n\n        Gets the type of polynomial basis used to\n        describe the polynomial eigenvalue problem.\n\n        Returns\n        -------\n        basis: `PEP.Basis` enumerate\n            the basis that was previously set.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_23getBasis(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getBasis (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getBasis", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBasis", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_22getBasis(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_22getBasis(struct PySlepcPEPObject *__pyx_v_self) {
  PEPBasis __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getBasis", 0);

  /* "SLEPc/PEP.pyx":370
 *             the basis that was previously set.
 *         """
 *         cdef SlepcPEPBasis val = PEP_BASIS_MONOMIAL             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetBasis(self.pep, &val) )
 *         return val
 */
  __pyx_v_val = PEP_BASIS_MONOMIAL;

  /* "SLEPc/PEP.pyx":371
 *         """
 *         cdef SlepcPEPBasis val = PEP_BASIS_MONOMIAL
 *         CHKERR( PEPGetBasis(self.pep, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetBasis(__pyx_v_self->pep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 371, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":372
 *         cdef SlepcPEPBasis val = PEP_BASIS_MONOMIAL
 *         CHKERR( PEPGetBasis(self.pep, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setBasis(self, basis):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_PEPBasis(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 372, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":360
 *         CHKERR( PEPSetFromOptions(self.pep) )
 * 
 *     def getBasis(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the type of polynomial basis used to
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getBasis", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":374
 *         return val
 * 
 *     def setBasis(self, basis):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the type of polynomial basis used to
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_25setBasis(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_24setBasis[] = "PEP.setBasis(self, basis)\n\n        Specifies the type of polynomial basis used to\n        describe the polynomial eigenvalue problem.\n\n        Parameters\n        ----------\n        basis: `PEP.Basis` enumerate\n            the basis to be set.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_25setBasis(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_basis = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setBasis (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_basis,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_basis)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setBasis") < 0)) __PYX_ERR(19, 374, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_basis = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setBasis", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 374, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setBasis", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_24setBasis(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_basis);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_24setBasis(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_basis) {
  PEPBasis __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PEPBasis __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setBasis", 0);

  /* "SLEPc/PEP.pyx":384
 *             the basis to be set.
 *         """
 *         cdef SlepcPEPBasis val = basis             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetBasis(self.pep, val) )
 * 
 */
  __pyx_t_1 = ((PEPBasis)__Pyx_PyInt_As_PEPBasis(__pyx_v_basis)); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 384, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/PEP.pyx":385
 *         """
 *         cdef SlepcPEPBasis val = basis
 *         CHKERR( PEPSetBasis(self.pep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getProblemType(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetBasis(__pyx_v_self->pep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 385, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":374
 *         return val
 * 
 *     def setBasis(self, basis):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the type of polynomial basis used to
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setBasis", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":387
 *         CHKERR( PEPSetBasis(self.pep, val) )
 * 
 *     def getProblemType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the problem type from the PEP object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_27getProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_26getProblemType[] = "PEP.getProblemType(self)\n\n        Gets the problem type from the PEP object.\n\n        Returns\n        -------\n        problem_type: `PEP.ProblemType` enumerate\n            The problem type that was previously set.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_27getProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getProblemType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getProblemType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getProblemType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_26getProblemType(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_26getProblemType(struct PySlepcPEPObject *__pyx_v_self) {
  PEPProblemType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getProblemType", 0);

  /* "SLEPc/PEP.pyx":396
 *             The problem type that was previously set.
 *         """
 *         cdef SlepcPEPProblemType val = PEP_GENERAL             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetProblemType(self.pep, &val) )
 *         return val
 */
  __pyx_v_val = PEP_GENERAL;

  /* "SLEPc/PEP.pyx":397
 *         """
 *         cdef SlepcPEPProblemType val = PEP_GENERAL
 *         CHKERR( PEPGetProblemType(self.pep, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetProblemType(__pyx_v_self->pep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 397, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":398
 *         cdef SlepcPEPProblemType val = PEP_GENERAL
 *         CHKERR( PEPGetProblemType(self.pep, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setProblemType(self, problem_type):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_PEPProblemType(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 398, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":387
 *         CHKERR( PEPSetBasis(self.pep, val) )
 * 
 *     def getProblemType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the problem type from the PEP object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getProblemType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":400
 *         return val
 * 
 *     def setProblemType(self, problem_type):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the type of the eigenvalue problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_29setProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_28setProblemType[] = "PEP.setProblemType(self, problem_type)\n\n        Specifies the type of the eigenvalue problem.\n\n        Parameters\n        ----------\n        problem_type: `PEP.ProblemType` enumerate\n            The problem type to be set.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_29setProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_problem_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setProblemType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_problem_type,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_problem_type)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setProblemType") < 0)) __PYX_ERR(19, 400, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_problem_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setProblemType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 400, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setProblemType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_28setProblemType(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_problem_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_28setProblemType(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_problem_type) {
  PEPProblemType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PEPProblemType __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setProblemType", 0);

  /* "SLEPc/PEP.pyx":409
 *             The problem type to be set.
 *         """
 *         cdef SlepcPEPProblemType val = problem_type             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetProblemType(self.pep, val) )
 * 
 */
  __pyx_t_1 = ((PEPProblemType)__Pyx_PyInt_As_PEPProblemType(__pyx_v_problem_type)); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 409, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/PEP.pyx":410
 *         """
 *         cdef SlepcPEPProblemType val = problem_type
 *         CHKERR( PEPSetProblemType(self.pep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getWhichEigenpairs(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetProblemType(__pyx_v_self->pep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 410, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":400
 *         return val
 * 
 *     def setProblemType(self, problem_type):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the type of the eigenvalue problem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setProblemType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":412
 *         CHKERR( PEPSetProblemType(self.pep, val) )
 * 
 *     def getWhichEigenpairs(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns which portion of the spectrum is to be sought.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_31getWhichEigenpairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_30getWhichEigenpairs[] = "PEP.getWhichEigenpairs(self)\n\n        Returns which portion of the spectrum is to be sought.\n\n        Returns\n        -------\n        which: `PEP.Which` enumerate\n            The portion of the spectrum to be sought by the solver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_31getWhichEigenpairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getWhichEigenpairs (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getWhichEigenpairs", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getWhichEigenpairs", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_30getWhichEigenpairs(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_30getWhichEigenpairs(struct PySlepcPEPObject *__pyx_v_self) {
  PEPWhich __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getWhichEigenpairs", 0);

  /* "SLEPc/PEP.pyx":421
 *             The portion of the spectrum to be sought by the solver.
 *         """
 *         cdef SlepcPEPWhich val = PEP_LARGEST_MAGNITUDE             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetWhichEigenpairs(self.pep, &val) )
 *         return val
 */
  __pyx_v_val = PEP_LARGEST_MAGNITUDE;

  /* "SLEPc/PEP.pyx":422
 *         """
 *         cdef SlepcPEPWhich val = PEP_LARGEST_MAGNITUDE
 *         CHKERR( PEPGetWhichEigenpairs(self.pep, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetWhichEigenpairs(__pyx_v_self->pep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 422, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":423
 *         cdef SlepcPEPWhich val = PEP_LARGEST_MAGNITUDE
 *         CHKERR( PEPGetWhichEigenpairs(self.pep, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setWhichEigenpairs(self, which):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_PEPWhich(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 423, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":412
 *         CHKERR( PEPSetProblemType(self.pep, val) )
 * 
 *     def getWhichEigenpairs(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns which portion of the spectrum is to be sought.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getWhichEigenpairs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":425
 *         return val
 * 
 *     def setWhichEigenpairs(self, which):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies which portion of the spectrum is to be sought.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_33setWhichEigenpairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_32setWhichEigenpairs[] = "PEP.setWhichEigenpairs(self, which)\n\n        Specifies which portion of the spectrum is to be sought.\n\n        Parameters\n        ----------\n        which: `PEP.Which` enumerate\n            The portion of the spectrum to be sought by the solver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_33setWhichEigenpairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_which = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setWhichEigenpairs (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_which,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_which)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setWhichEigenpairs") < 0)) __PYX_ERR(19, 425, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_which = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setWhichEigenpairs", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 425, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setWhichEigenpairs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_32setWhichEigenpairs(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_which);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_32setWhichEigenpairs(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_which) {
  PEPWhich __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PEPWhich __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setWhichEigenpairs", 0);

  /* "SLEPc/PEP.pyx":434
 *             The portion of the spectrum to be sought by the solver.
 *         """
 *         cdef SlepcPEPWhich val = which             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetWhichEigenpairs(self.pep, val) )
 * 
 */
  __pyx_t_1 = ((PEPWhich)__Pyx_PyInt_As_PEPWhich(__pyx_v_which)); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 434, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/PEP.pyx":435
 *         """
 *         cdef SlepcPEPWhich val = which
 *         CHKERR( PEPSetWhichEigenpairs(self.pep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getTarget(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetWhichEigenpairs(__pyx_v_self->pep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 435, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":425
 *         return val
 * 
 *     def setWhichEigenpairs(self, which):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies which portion of the spectrum is to be sought.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setWhichEigenpairs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":437
 *         CHKERR( PEPSetWhichEigenpairs(self.pep, val) )
 * 
 *     def getTarget(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the value of the target.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_35getTarget(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_34getTarget[] = "PEP.getTarget(self)\n\n        Gets the value of the target.\n\n        Returns\n        -------\n        target: float (real or complex)\n                The value of the target.\n\n        Notes\n        -----\n        If the target was not set by the user, then zero is returned.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_35getTarget(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTarget (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTarget", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTarget", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_34getTarget(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_34getTarget(struct PySlepcPEPObject *__pyx_v_self) {
  PetscScalar __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTarget", 0);

  /* "SLEPc/PEP.pyx":450
 *         If the target was not set by the user, then zero is returned.
 *         """
 *         cdef PetscScalar sval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetTarget(self.pep, &sval) )
 *         return toScalar(sval)
 */
  __pyx_v_sval = 0.0;

  /* "SLEPc/PEP.pyx":451
 *         """
 *         cdef PetscScalar sval = 0
 *         CHKERR( PEPGetTarget(self.pep, &sval) )             # <<<<<<<<<<<<<<
 *         return toScalar(sval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetTarget(__pyx_v_self->pep, (&__pyx_v_sval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 451, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":452
 *         cdef PetscScalar sval = 0
 *         CHKERR( PEPGetTarget(self.pep, &sval) )
 *         return toScalar(sval)             # <<<<<<<<<<<<<<
 * 
 *     def setTarget(self, target):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_sval); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 452, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":437
 *         CHKERR( PEPSetWhichEigenpairs(self.pep, val) )
 * 
 *     def getTarget(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the value of the target.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getTarget", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":454
 *         return toScalar(sval)
 * 
 *     def setTarget(self, target):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the value of the target.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_37setTarget(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_36setTarget[] = "PEP.setTarget(self, target)\n\n        Sets the value of the target.\n\n        Parameters\n        ----------\n        target: float (real or complex)\n                The value of the target.\n\n        Notes\n        -----\n        The target is a scalar value used to determine the portion of\n        the spectrum of interest. It is used in combination with\n        `setWhichEigenpairs()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_37setTarget(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_target = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTarget (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_target,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_target)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTarget") < 0)) __PYX_ERR(19, 454, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_target = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTarget", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 454, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setTarget", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_36setTarget(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_target);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_36setTarget(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_target) {
  PetscScalar __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTarget", 0);

  /* "SLEPc/PEP.pyx":469
 *         `setWhichEigenpairs()`.
 *         """
 *         cdef PetscScalar sval = asScalar(target)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetTarget(self.pep, sval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_target); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(19, 469, __pyx_L1_error)
  __pyx_v_sval = __pyx_t_1;

  /* "SLEPc/PEP.pyx":470
 *         """
 *         cdef PetscScalar sval = asScalar(target)
 *         CHKERR( PEPSetTarget(self.pep, sval) )             # <<<<<<<<<<<<<<
 * 
 *     def getTolerances(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetTarget(__pyx_v_self->pep, __pyx_v_sval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 470, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":454
 *         return toScalar(sval)
 * 
 *     def setTarget(self, target):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the value of the target.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setTarget", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":472
 *         CHKERR( PEPSetTarget(self.pep, sval) )
 * 
 *     def getTolerances(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance and maximum iteration count used by the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_39getTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_38getTolerances[] = "PEP.getTolerances(self)\n\n        Gets the tolerance and maximum iteration count used by the\n        default PEP convergence tests.\n\n        Returns\n        -------\n        tol: float\n            The convergence tolerance.\n        max_it: int\n            The maximum number of iterations\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_39getTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTolerances (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTolerances", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTolerances", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_38getTolerances(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_38getTolerances(struct PySlepcPEPObject *__pyx_v_self) {
  PetscReal __pyx_v_rval;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTolerances", 0);

  /* "SLEPc/PEP.pyx":484
 *             The maximum number of iterations
 *         """
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = 0
 *         CHKERR( PEPGetTolerances(self.pep, &rval, &ival) )
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/PEP.pyx":485
 *         """
 *         cdef PetscReal rval = 0
 *         cdef PetscInt  ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetTolerances(self.pep, &rval, &ival) )
 *         return (toReal(rval), toInt(ival))
 */
  __pyx_v_ival = 0;

  /* "SLEPc/PEP.pyx":486
 *         cdef PetscReal rval = 0
 *         cdef PetscInt  ival = 0
 *         CHKERR( PEPGetTolerances(self.pep, &rval, &ival) )             # <<<<<<<<<<<<<<
 *         return (toReal(rval), toInt(ival))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetTolerances(__pyx_v_self->pep, (&__pyx_v_rval), (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 486, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":487
 *         cdef PetscInt  ival = 0
 *         CHKERR( PEPGetTolerances(self.pep, &rval, &ival) )
 *         return (toReal(rval), toInt(ival))             # <<<<<<<<<<<<<<
 * 
 *     def setTolerances(self, tol=None, max_it=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 487, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 487, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 487, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":472
 *         CHKERR( PEPSetTarget(self.pep, sval) )
 * 
 *     def getTolerances(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance and maximum iteration count used by the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":489
 *         return (toReal(rval), toInt(ival))
 * 
 *     def setTolerances(self, tol=None, max_it=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance and maximum iteration count used by the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_41setTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_40setTolerances[] = "PEP.setTolerances(self, tol=None, max_it=None)\n\n        Sets the tolerance and maximum iteration count used by the\n        default PEP convergence tests.\n\n        Parameters\n        ----------\n        tol: float, optional\n            The convergence tolerance.\n        max_it: int, optional\n            The maximum number of iterations\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_41setTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_tol = 0;
  PyObject *__pyx_v_max_it = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTolerances (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_tol,&__pyx_n_s_max_it,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tol);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_it);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTolerances") < 0)) __PYX_ERR(19, 489, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_tol = values[0];
    __pyx_v_max_it = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTolerances", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 489, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_40setTolerances(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_tol, __pyx_v_max_it);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_40setTolerances(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_tol, PyObject *__pyx_v_max_it) {
  PetscReal __pyx_v_rval;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscReal __pyx_t_3;
  PetscInt __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTolerances", 0);

  /* "SLEPc/PEP.pyx":501
 *             The maximum number of iterations
 *         """
 *         cdef PetscReal rval = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol    is not None: rval = asReal(tol)
 */
  __pyx_v_rval = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":502
 *         """
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if tol    is not None: rval = asReal(tol)
 *         if max_it is not None: ival = asInt(max_it)
 */
  __pyx_v_ival = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":503
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol    is not None: rval = asReal(tol)             # <<<<<<<<<<<<<<
 *         if max_it is not None: ival = asInt(max_it)
 *         CHKERR( PEPSetTolerances(self.pep, rval, ival) )
 */
  __pyx_t_1 = (__pyx_v_tol != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_tol); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 503, __pyx_L1_error)
    __pyx_v_rval = __pyx_t_3;
  }

  /* "SLEPc/PEP.pyx":504
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol    is not None: rval = asReal(tol)
 *         if max_it is not None: ival = asInt(max_it)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetTolerances(self.pep, rval, ival) )
 * 
 */
  __pyx_t_2 = (__pyx_v_max_it != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_max_it); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 504, __pyx_L1_error)
    __pyx_v_ival = __pyx_t_4;
  }

  /* "SLEPc/PEP.pyx":505
 *         if tol    is not None: rval = asReal(tol)
 *         if max_it is not None: ival = asInt(max_it)
 *         CHKERR( PEPSetTolerances(self.pep, rval, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getInterval(self):
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetTolerances(__pyx_v_self->pep, __pyx_v_rval, __pyx_v_ival)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(19, 505, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":489
 *         return (toReal(rval), toInt(ival))
 * 
 *     def setTolerances(self, tol=None, max_it=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance and maximum iteration count used by the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":507
 *         CHKERR( PEPSetTolerances(self.pep, rval, ival) )
 * 
 *     def getInterval(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the computational interval for spectrum slicing.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_43getInterval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_42getInterval[] = "PEP.getInterval(self)\n\n        Gets the computational interval for spectrum slicing.\n\n        Returns\n        -------\n        inta: float\n                The left end of the interval.\n        intb: float\n                The right end of the interval.\n\n        Notes\n        -----\n        If the interval was not set by the user, then zeros are returned.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_43getInterval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getInterval (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getInterval", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getInterval", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_42getInterval(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_42getInterval(struct PySlepcPEPObject *__pyx_v_self) {
  PetscReal __pyx_v_inta;
  PetscReal __pyx_v_intb;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getInterval", 0);

  /* "SLEPc/PEP.pyx":522
 *         If the interval was not set by the user, then zeros are returned.
 *         """
 *         cdef PetscReal inta = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal intb = 0
 *         CHKERR( PEPGetInterval(self.pep, &inta, &intb) )
 */
  __pyx_v_inta = 0.0;

  /* "SLEPc/PEP.pyx":523
 *         """
 *         cdef PetscReal inta = 0
 *         cdef PetscReal intb = 0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetInterval(self.pep, &inta, &intb) )
 *         return (toReal(inta), toReal(intb))
 */
  __pyx_v_intb = 0.0;

  /* "SLEPc/PEP.pyx":524
 *         cdef PetscReal inta = 0
 *         cdef PetscReal intb = 0
 *         CHKERR( PEPGetInterval(self.pep, &inta, &intb) )             # <<<<<<<<<<<<<<
 *         return (toReal(inta), toReal(intb))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetInterval(__pyx_v_self->pep, (&__pyx_v_inta), (&__pyx_v_intb))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 524, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":525
 *         cdef PetscReal intb = 0
 *         CHKERR( PEPGetInterval(self.pep, &inta, &intb) )
 *         return (toReal(inta), toReal(intb))             # <<<<<<<<<<<<<<
 * 
 *     def setInterval(self, inta, intb):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_inta); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 525, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_intb); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 525, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 525, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":507
 *         CHKERR( PEPSetTolerances(self.pep, rval, ival) )
 * 
 *     def getInterval(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the computational interval for spectrum slicing.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getInterval", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":527
 *         return (toReal(inta), toReal(intb))
 * 
 *     def setInterval(self, inta, intb):             # <<<<<<<<<<<<<<
 *         """
 *         Defines the computational interval for spectrum slicing.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_45setInterval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_44setInterval[] = "PEP.setInterval(self, inta, intb)\n\n        Defines the computational interval for spectrum slicing.\n\n        Parameters\n        ----------\n        inta: float\n                The left end of the interval.\n        intb: float\n                The right end of the interval.\n\n        Notes\n        -----\n        Spectrum slicing is a technique employed for computing all\n        eigenvalues of symmetric quadratic eigenproblems in a given interval.\n        This function provides the interval to be considered. It must\n        be used in combination with `PEP.Which.ALL`, see\n        `setWhichEigenpairs()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_45setInterval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_inta = 0;
  PyObject *__pyx_v_intb = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setInterval (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inta,&__pyx_n_s_intb,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_inta)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_intb)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setInterval", 1, 2, 2, 1); __PYX_ERR(19, 527, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setInterval") < 0)) __PYX_ERR(19, 527, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_inta = values[0];
    __pyx_v_intb = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setInterval", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 527, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setInterval", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_44setInterval(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_inta, __pyx_v_intb);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_44setInterval(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_inta, PyObject *__pyx_v_intb) {
  PetscReal __pyx_v_rval1;
  PetscReal __pyx_v_rval2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setInterval", 0);

  /* "SLEPc/PEP.pyx":546
 *         `setWhichEigenpairs()`.
 *         """
 *         cdef PetscReal rval1 = asReal(inta)             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval2 = asReal(intb)
 *         CHKERR( PEPSetInterval(self.pep, rval1, rval2) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_inta); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 546, __pyx_L1_error)
  __pyx_v_rval1 = __pyx_t_1;

  /* "SLEPc/PEP.pyx":547
 *         """
 *         cdef PetscReal rval1 = asReal(inta)
 *         cdef PetscReal rval2 = asReal(intb)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetInterval(self.pep, rval1, rval2) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_intb); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 547, __pyx_L1_error)
  __pyx_v_rval2 = __pyx_t_1;

  /* "SLEPc/PEP.pyx":548
 *         cdef PetscReal rval1 = asReal(inta)
 *         cdef PetscReal rval2 = asReal(intb)
 *         CHKERR( PEPSetInterval(self.pep, rval1, rval2) )             # <<<<<<<<<<<<<<
 * 
 *     def getConvergenceTest(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetInterval(__pyx_v_self->pep, __pyx_v_rval1, __pyx_v_rval2)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 548, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":527
 *         return (toReal(inta), toReal(intb))
 * 
 *     def setInterval(self, inta, intb):             # <<<<<<<<<<<<<<
 *         """
 *         Defines the computational interval for spectrum slicing.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setInterval", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":550
 *         CHKERR( PEPSetInterval(self.pep, rval1, rval2) )
 * 
 *     def getConvergenceTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Return the method used to compute the error estimate
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_47getConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_46getConvergenceTest[] = "PEP.getConvergenceTest(self)\n\n        Return the method used to compute the error estimate\n        used in the convergence test.\n\n        Returns\n        -------\n        conv: PEP.Conv\n            The method used to compute the error estimate\n            used in the convergence test.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_47getConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getConvergenceTest (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getConvergenceTest", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConvergenceTest", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_46getConvergenceTest(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_46getConvergenceTest(struct PySlepcPEPObject *__pyx_v_self) {
  PEPConv __pyx_v_conv;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getConvergenceTest", 0);

  /* "SLEPc/PEP.pyx":561
 *             used in the convergence test.
 *         """
 *         cdef SlepcPEPConv conv = PEP_CONV_REL             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetConvergenceTest(self.pep, &conv) )
 *         return conv
 */
  __pyx_v_conv = PEP_CONV_REL;

  /* "SLEPc/PEP.pyx":562
 *         """
 *         cdef SlepcPEPConv conv = PEP_CONV_REL
 *         CHKERR( PEPGetConvergenceTest(self.pep, &conv) )             # <<<<<<<<<<<<<<
 *         return conv
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetConvergenceTest(__pyx_v_self->pep, (&__pyx_v_conv))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 562, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":563
 *         cdef SlepcPEPConv conv = PEP_CONV_REL
 *         CHKERR( PEPGetConvergenceTest(self.pep, &conv) )
 *         return conv             # <<<<<<<<<<<<<<
 * 
 *     def setConvergenceTest(self, conv):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_PEPConv(__pyx_v_conv); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 563, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":550
 *         CHKERR( PEPSetInterval(self.pep, rval1, rval2) )
 * 
 *     def getConvergenceTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Return the method used to compute the error estimate
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getConvergenceTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":565
 *         return conv
 * 
 *     def setConvergenceTest(self, conv):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies how to compute the error estimate
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_49setConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_48setConvergenceTest[] = "PEP.setConvergenceTest(self, conv)\n\n        Specifies how to compute the error estimate\n        used in the convergence test.\n\n        Parameters\n        ----------\n        conv: PEP.Conv\n            The method used to compute the error estimate\n            used in the convergence test.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_49setConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_conv = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setConvergenceTest (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_conv,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_conv)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setConvergenceTest") < 0)) __PYX_ERR(19, 565, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_conv = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setConvergenceTest", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 565, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setConvergenceTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_48setConvergenceTest(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_conv);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_48setConvergenceTest(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_conv) {
  PEPConv __pyx_v_tconv;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PEPConv __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setConvergenceTest", 0);

  /* "SLEPc/PEP.pyx":576
 *             used in the convergence test.
 *         """
 *         cdef SlepcPEPConv tconv = conv             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetConvergenceTest(self.pep, tconv) )
 * 
 */
  __pyx_t_1 = ((PEPConv)__Pyx_PyInt_As_PEPConv(__pyx_v_conv)); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 576, __pyx_L1_error)
  __pyx_v_tconv = __pyx_t_1;

  /* "SLEPc/PEP.pyx":577
 *         """
 *         cdef SlepcPEPConv tconv = conv
 *         CHKERR( PEPSetConvergenceTest(self.pep, tconv) )             # <<<<<<<<<<<<<<
 * 
 *     def getRefine(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetConvergenceTest(__pyx_v_self->pep, __pyx_v_tconv)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 577, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":565
 *         return conv
 * 
 *     def setConvergenceTest(self, conv):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies how to compute the error estimate
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setConvergenceTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":579
 *         CHKERR( PEPSetConvergenceTest(self.pep, tconv) )
 * 
 *     def getRefine(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the refinement strategy used by the PEP object,
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_51getRefine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_50getRefine[] = "PEP.getRefine(self)\n\n        Gets the refinement strategy used by the PEP object,\n        and the associated parameters.\n\n        Returns\n        -------\n        ref: PEP.Refine\n            The refinement type.\n        npart: int\n            The number of partitions of the communicator.\n        tol: real\n            The convergence tolerance.\n        its: int\n            The maximum number of refinement iterations.\n        scheme: PEP.RefineScheme\n            Scheme for solving linear systems\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_51getRefine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRefine (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRefine", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRefine", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_50getRefine(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_50getRefine(struct PySlepcPEPObject *__pyx_v_self) {
  PEPRefine __pyx_v_ref;
  PetscInt __pyx_v_npart;
  PetscReal __pyx_v_tol;
  PetscInt __pyx_v_its;
  PEPRefineScheme __pyx_v_scheme;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRefine", 0);

  /* "SLEPc/PEP.pyx":597
 *             Scheme for solving linear systems
 *         """
 *         cdef SlepcPEPRefine ref = PEP_REFINE_NONE             # <<<<<<<<<<<<<<
 *         cdef PetscInt npart = 1
 *         cdef PetscReal tol = PETSC_DEFAULT
 */
  __pyx_v_ref = PEP_REFINE_NONE;

  /* "SLEPc/PEP.pyx":598
 *         """
 *         cdef SlepcPEPRefine ref = PEP_REFINE_NONE
 *         cdef PetscInt npart = 1             # <<<<<<<<<<<<<<
 *         cdef PetscReal tol = PETSC_DEFAULT
 *         cdef PetscInt its = PETSC_DEFAULT
 */
  __pyx_v_npart = 1;

  /* "SLEPc/PEP.pyx":599
 *         cdef SlepcPEPRefine ref = PEP_REFINE_NONE
 *         cdef PetscInt npart = 1
 *         cdef PetscReal tol = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt its = PETSC_DEFAULT
 *         cdef SlepcPEPRefineScheme scheme = PEP_REFINE_SCHEME_MBE
 */
  __pyx_v_tol = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":600
 *         cdef PetscInt npart = 1
 *         cdef PetscReal tol = PETSC_DEFAULT
 *         cdef PetscInt its = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef SlepcPEPRefineScheme scheme = PEP_REFINE_SCHEME_MBE
 *         CHKERR( PEPGetRefine(self.pep, &ref, &npart, &tol, &its, &scheme) )
 */
  __pyx_v_its = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":601
 *         cdef PetscReal tol = PETSC_DEFAULT
 *         cdef PetscInt its = PETSC_DEFAULT
 *         cdef SlepcPEPRefineScheme scheme = PEP_REFINE_SCHEME_MBE             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetRefine(self.pep, &ref, &npart, &tol, &its, &scheme) )
 *         return (ref, toInt(npart), toReal(tol), toInt(its), scheme)
 */
  __pyx_v_scheme = PEP_REFINE_SCHEME_MBE;

  /* "SLEPc/PEP.pyx":602
 *         cdef PetscInt its = PETSC_DEFAULT
 *         cdef SlepcPEPRefineScheme scheme = PEP_REFINE_SCHEME_MBE
 *         CHKERR( PEPGetRefine(self.pep, &ref, &npart, &tol, &its, &scheme) )             # <<<<<<<<<<<<<<
 *         return (ref, toInt(npart), toReal(tol), toInt(its), scheme)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetRefine(__pyx_v_self->pep, (&__pyx_v_ref), (&__pyx_v_npart), (&__pyx_v_tol), (&__pyx_v_its), (&__pyx_v_scheme))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 602, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":603
 *         cdef SlepcPEPRefineScheme scheme = PEP_REFINE_SCHEME_MBE
 *         CHKERR( PEPGetRefine(self.pep, &ref, &npart, &tol, &its, &scheme) )
 *         return (ref, toInt(npart), toReal(tol), toInt(its), scheme)             # <<<<<<<<<<<<<<
 * 
 *     def setRefine(self, ref, npart=None, tol=None, its=None, scheme=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_PEPRefine(__pyx_v_ref); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 603, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_npart); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 603, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_tol); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 603, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_its); if (unlikely(!__pyx_t_5)) __PYX_ERR(19, 603, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyInt_From_PEPRefineScheme(__pyx_v_scheme); if (unlikely(!__pyx_t_6)) __PYX_ERR(19, 603, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(19, 603, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_7, 4, __pyx_t_6);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_t_6 = 0;
  __pyx_r = __pyx_t_7;
  __pyx_t_7 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":579
 *         CHKERR( PEPSetConvergenceTest(self.pep, tconv) )
 * 
 *     def getRefine(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the refinement strategy used by the PEP object,
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getRefine", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":605
 *         return (ref, toInt(npart), toReal(tol), toInt(its), scheme)
 * 
 *     def setRefine(self, ref, npart=None, tol=None, its=None, scheme=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the refinement strategy used by the PEP object,
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_53setRefine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_52setRefine[] = "PEP.setRefine(self, ref, npart=None, tol=None, its=None, scheme=None)\n\n        Sets the refinement strategy used by the PEP object,\n        and the associated parameters.\n\n        Parameters\n        ----------\n        ref: PEP.Refine\n            The refinement type.\n        npart: int, optional\n            The number of partitions of the communicator.\n        tol: real, optional\n            The convergence tolerance.\n        its: int, optional\n            The maximum number of refinement iterations.\n        scheme: PEP.RefineScheme, optional\n            Scheme for linear system solves\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_53setRefine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_ref = 0;
  PyObject *__pyx_v_npart = 0;
  PyObject *__pyx_v_tol = 0;
  PyObject *__pyx_v_its = 0;
  PyObject *__pyx_v_scheme = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRefine (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ref,&__pyx_n_s_npart,&__pyx_n_s_tol,&__pyx_n_s_its,&__pyx_n_s_scheme,0};
    PyObject* values[5] = {0,0,0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    values[3] = ((PyObject *)Py_None);
    values[4] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ref)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_npart);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tol);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_its);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_scheme);
          if (value) { values[4] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRefine") < 0)) __PYX_ERR(19, 605, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_ref = values[0];
    __pyx_v_npart = values[1];
    __pyx_v_tol = values[2];
    __pyx_v_its = values[3];
    __pyx_v_scheme = values[4];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRefine", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 605, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setRefine", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_52setRefine(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_ref, __pyx_v_npart, __pyx_v_tol, __pyx_v_its, __pyx_v_scheme);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_52setRefine(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_ref, PyObject *__pyx_v_npart, PyObject *__pyx_v_tol, PyObject *__pyx_v_its, PyObject *__pyx_v_scheme) {
  PEPRefine __pyx_v_tref;
  PetscInt __pyx_v_tnpart;
  PetscReal __pyx_v_ttol;
  PetscInt __pyx_v_tits;
  PEPRefineScheme __pyx_v_tscheme;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PEPRefine __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PetscInt __pyx_t_4;
  PetscReal __pyx_t_5;
  PEPRefineScheme __pyx_t_6;
  int __pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRefine", 0);

  /* "SLEPc/PEP.pyx":623
 *             Scheme for linear system solves
 *         """
 *         cdef SlepcPEPRefine tref = ref             # <<<<<<<<<<<<<<
 *         cdef PetscInt tnpart = 1
 *         cdef PetscReal ttol = PETSC_DEFAULT
 */
  __pyx_t_1 = ((PEPRefine)__Pyx_PyInt_As_PEPRefine(__pyx_v_ref)); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 623, __pyx_L1_error)
  __pyx_v_tref = __pyx_t_1;

  /* "SLEPc/PEP.pyx":624
 *         """
 *         cdef SlepcPEPRefine tref = ref
 *         cdef PetscInt tnpart = 1             # <<<<<<<<<<<<<<
 *         cdef PetscReal ttol = PETSC_DEFAULT
 *         cdef PetscInt tits = PETSC_DEFAULT
 */
  __pyx_v_tnpart = 1;

  /* "SLEPc/PEP.pyx":625
 *         cdef SlepcPEPRefine tref = ref
 *         cdef PetscInt tnpart = 1
 *         cdef PetscReal ttol = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt tits = PETSC_DEFAULT
 *         cdef SlepcPEPRefineScheme tscheme = PEP_REFINE_SCHEME_MBE
 */
  __pyx_v_ttol = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":626
 *         cdef PetscInt tnpart = 1
 *         cdef PetscReal ttol = PETSC_DEFAULT
 *         cdef PetscInt tits = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef SlepcPEPRefineScheme tscheme = PEP_REFINE_SCHEME_MBE
 *         if npart is not None: tnpart = asInt(npart)
 */
  __pyx_v_tits = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":627
 *         cdef PetscReal ttol = PETSC_DEFAULT
 *         cdef PetscInt tits = PETSC_DEFAULT
 *         cdef SlepcPEPRefineScheme tscheme = PEP_REFINE_SCHEME_MBE             # <<<<<<<<<<<<<<
 *         if npart is not None: tnpart = asInt(npart)
 *         if tol is not None: ttol = asReal(tol)
 */
  __pyx_v_tscheme = PEP_REFINE_SCHEME_MBE;

  /* "SLEPc/PEP.pyx":628
 *         cdef PetscInt tits = PETSC_DEFAULT
 *         cdef SlepcPEPRefineScheme tscheme = PEP_REFINE_SCHEME_MBE
 *         if npart is not None: tnpart = asInt(npart)             # <<<<<<<<<<<<<<
 *         if tol is not None: ttol = asReal(tol)
 *         if its is not None: tits = asInt(its)
 */
  __pyx_t_2 = (__pyx_v_npart != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_npart); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 628, __pyx_L1_error)
    __pyx_v_tnpart = __pyx_t_4;
  }

  /* "SLEPc/PEP.pyx":629
 *         cdef SlepcPEPRefineScheme tscheme = PEP_REFINE_SCHEME_MBE
 *         if npart is not None: tnpart = asInt(npart)
 *         if tol is not None: ttol = asReal(tol)             # <<<<<<<<<<<<<<
 *         if its is not None: tits = asInt(its)
 *         if scheme is not None: tscheme = scheme
 */
  __pyx_t_3 = (__pyx_v_tol != Py_None);
  __pyx_t_2 = (__pyx_t_3 != 0);
  if (__pyx_t_2) {
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_tol); if (unlikely(__pyx_t_5 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 629, __pyx_L1_error)
    __pyx_v_ttol = __pyx_t_5;
  }

  /* "SLEPc/PEP.pyx":630
 *         if npart is not None: tnpart = asInt(npart)
 *         if tol is not None: ttol = asReal(tol)
 *         if its is not None: tits = asInt(its)             # <<<<<<<<<<<<<<
 *         if scheme is not None: tscheme = scheme
 *         CHKERR( PEPSetRefine(self.pep, tref, tnpart, ttol, tits, tscheme) )
 */
  __pyx_t_2 = (__pyx_v_its != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_its); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 630, __pyx_L1_error)
    __pyx_v_tits = __pyx_t_4;
  }

  /* "SLEPc/PEP.pyx":631
 *         if tol is not None: ttol = asReal(tol)
 *         if its is not None: tits = asInt(its)
 *         if scheme is not None: tscheme = scheme             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetRefine(self.pep, tref, tnpart, ttol, tits, tscheme) )
 * 
 */
  __pyx_t_3 = (__pyx_v_scheme != Py_None);
  __pyx_t_2 = (__pyx_t_3 != 0);
  if (__pyx_t_2) {
    __pyx_t_6 = ((PEPRefineScheme)__Pyx_PyInt_As_PEPRefineScheme(__pyx_v_scheme)); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 631, __pyx_L1_error)
    __pyx_v_tscheme = __pyx_t_6;
  }

  /* "SLEPc/PEP.pyx":632
 *         if its is not None: tits = asInt(its)
 *         if scheme is not None: tscheme = scheme
 *         CHKERR( PEPSetRefine(self.pep, tref, tnpart, ttol, tits, tscheme) )             # <<<<<<<<<<<<<<
 * 
 *     def getRefineKSP(self):
 */
  __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetRefine(__pyx_v_self->pep, __pyx_v_tref, __pyx_v_tnpart, __pyx_v_ttol, __pyx_v_tits, __pyx_v_tscheme)); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(19, 632, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":605
 *         return (ref, toInt(npart), toReal(tol), toInt(its), scheme)
 * 
 *     def setRefine(self, ref, npart=None, tol=None, its=None, scheme=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the refinement strategy used by the PEP object,
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setRefine", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":634
 *         CHKERR( PEPSetRefine(self.pep, tref, tnpart, ttol, tits, tscheme) )
 * 
 *     def getRefineKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the `KSP` object used by the eigensolver in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_55getRefineKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_54getRefineKSP[] = "PEP.getRefineKSP(self)\n\n        Obtain the `KSP` object used by the eigensolver in the\n        refinement phase.\n\n        Returns\n        -------\n        ksp: `KSP`\n             The linear solver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_55getRefineKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRefineKSP (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRefineKSP", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRefineKSP", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_54getRefineKSP(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_54getRefineKSP(struct PySlepcPEPObject *__pyx_v_self) {
  struct PyPetscKSPObject *__pyx_v_ksp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRefineKSP", 0);

  /* "SLEPc/PEP.pyx":644
 *              The linear solver object.
 *         """
 *         cdef KSP ksp = KSP()             # <<<<<<<<<<<<<<
 *         CHKERR( PEPRefineGetKSP(self.pep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_KSP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 644, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ksp = ((struct PyPetscKSPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":645
 *         """
 *         cdef KSP ksp = KSP()
 *         CHKERR( PEPRefineGetKSP(self.pep, &ksp.ksp) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(ksp.obj)
 *         return ksp
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPRefineGetKSP(__pyx_v_self->pep, (&__pyx_v_ksp->ksp))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 645, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":646
 *         cdef KSP ksp = KSP()
 *         CHKERR( PEPRefineGetKSP(self.pep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)             # <<<<<<<<<<<<<<
 *         return ksp
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ksp->__pyx_base.obj));

  /* "SLEPc/PEP.pyx":647
 *         CHKERR( PEPRefineGetKSP(self.pep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 *         return ksp             # <<<<<<<<<<<<<<
 * 
 *     def setExtract(self, extract):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ksp));
  __pyx_r = ((PyObject *)__pyx_v_ksp);
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":634
 *         CHKERR( PEPSetRefine(self.pep, tref, tnpart, ttol, tits, tscheme) )
 * 
 *     def getRefineKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the `KSP` object used by the eigensolver in the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getRefineKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ksp);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":649
 *         return ksp
 * 
 *     def setExtract(self, extract):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the extraction strategy to be used.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_57setExtract(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_56setExtract[] = "PEP.setExtract(self, extract)\n\n        Specifies the extraction strategy to be used.\n\n        Parameters\n        ----------\n        extract: `PEP.Extract` enumerate\n               The extraction strategy.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_57setExtract(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_extract = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setExtract (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_extract,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_extract)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setExtract") < 0)) __PYX_ERR(19, 649, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_extract = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setExtract", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 649, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setExtract", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_56setExtract(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_extract);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_56setExtract(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_extract) {
  PEPExtract __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PEPExtract __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setExtract", 0);

  /* "SLEPc/PEP.pyx":658
 *                The extraction strategy.
 *         """
 *         cdef SlepcPEPExtract val = extract             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetExtract(self.pep, val) )
 * 
 */
  __pyx_t_1 = ((PEPExtract)__Pyx_PyInt_As_PEPExtract(__pyx_v_extract)); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 658, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/PEP.pyx":659
 *         """
 *         cdef SlepcPEPExtract val = extract
 *         CHKERR( PEPSetExtract(self.pep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getExtract(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetExtract(__pyx_v_self->pep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 659, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":649
 *         return ksp
 * 
 *     def setExtract(self, extract):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the extraction strategy to be used.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setExtract", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":661
 *         CHKERR( PEPSetExtract(self.pep, val) )
 * 
 *     def getExtract(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the extraction technique used by the `PEP` object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_59getExtract(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_58getExtract[] = "PEP.getExtract(self)\n\n        Gets the extraction technique used by the `PEP` object.\n\n        Returns\n        -------\n        extract: `PEP.Extract` enumerate\n               The extraction strategy.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_59getExtract(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getExtract (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getExtract", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getExtract", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_58getExtract(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_58getExtract(struct PySlepcPEPObject *__pyx_v_self) {
  PEPExtract __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getExtract", 0);

  /* "SLEPc/PEP.pyx":670
 *                The extraction strategy.
 *         """
 *         cdef SlepcPEPExtract val = PEP_EXTRACT_NONE             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetExtract(self.pep, &val) )
 *         return val
 */
  __pyx_v_val = PEP_EXTRACT_NONE;

  /* "SLEPc/PEP.pyx":671
 *         """
 *         cdef SlepcPEPExtract val = PEP_EXTRACT_NONE
 *         CHKERR( PEPGetExtract(self.pep, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetExtract(__pyx_v_self->pep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 671, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":672
 *         cdef SlepcPEPExtract val = PEP_EXTRACT_NONE
 *         CHKERR( PEPGetExtract(self.pep, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def getTrackAll(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_PEPExtract(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 672, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":661
 *         CHKERR( PEPSetExtract(self.pep, val) )
 * 
 *     def getExtract(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the extraction technique used by the `PEP` object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getExtract", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":674
 *         return val
 * 
 *     def getTrackAll(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether all residual norms must be
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_61getTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_60getTrackAll[] = "PEP.getTrackAll(self)\n\n        Returns the flag indicating whether all residual norms must be\n        computed or not.\n\n        Returns\n        -------\n        trackall: bool\n            Whether the solver compute all residuals or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_61getTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTrackAll (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTrackAll", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTrackAll", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_60getTrackAll(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_60getTrackAll(struct PySlepcPEPObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTrackAll", 0);

  /* "SLEPc/PEP.pyx":684
 *             Whether the solver compute all residuals or not.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetTrackAll(self.pep, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/PEP.pyx":685
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( PEPGetTrackAll(self.pep, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetTrackAll(__pyx_v_self->pep, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 685, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":686
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( PEPGetTrackAll(self.pep, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setTrackAll(self, trackall):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 686, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":674
 *         return val
 * 
 *     def getTrackAll(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether all residual norms must be
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getTrackAll", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":688
 *         return toBool(tval)
 * 
 *     def setTrackAll(self, trackall):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies if the solver must compute the residual of all
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_63setTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_62setTrackAll[] = "PEP.setTrackAll(self, trackall)\n\n        Specifies if the solver must compute the residual of all\n        approximate eigenpairs or not.\n\n        Parameters\n        ----------\n        trackall: bool\n            Whether compute all residuals or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_63setTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_trackall = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTrackAll (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_trackall,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_trackall)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTrackAll") < 0)) __PYX_ERR(19, 688, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_trackall = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTrackAll", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 688, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setTrackAll", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_62setTrackAll(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_trackall);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_62setTrackAll(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_trackall) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTrackAll", 0);

  /* "SLEPc/PEP.pyx":698
 *             Whether compute all residuals or not.
 *         """
 *         cdef PetscBool tval = trackall             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetTrackAll(self.pep, tval) )
 * 
 */
  __pyx_t_1 = ((PetscBool)__Pyx_PyInt_As_PetscBool(__pyx_v_trackall)); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 698, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/PEP.pyx":699
 *         """
 *         cdef PetscBool tval = trackall
 *         CHKERR( PEPSetTrackAll(self.pep, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getDimensions(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetTrackAll(__pyx_v_self->pep, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 699, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":688
 *         return toBool(tval)
 * 
 *     def setTrackAll(self, trackall):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies if the solver must compute the residual of all
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setTrackAll", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":701
 *         CHKERR( PEPSetTrackAll(self.pep, tval) )
 * 
 *     def getDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of eigenvalues to compute and the dimension of
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_65getDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_64getDimensions[] = "PEP.getDimensions(self)\n\n        Gets the number of eigenvalues to compute and the dimension of\n        the subspace.\n\n        Returns\n        -------\n        nev: int\n            Number of eigenvalues to compute.\n        ncv: int\n            Maximum dimension of the subspace to be used by the solver.\n        mpd: int\n            Maximum dimension allowed for the projected problem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_65getDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDimensions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getDimensions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDimensions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_64getDimensions(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_64getDimensions(struct PySlepcPEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getDimensions", 0);

  /* "SLEPc/PEP.pyx":715
 *             Maximum dimension allowed for the projected problem.
 *         """
 *         cdef PetscInt ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/PEP.pyx":716
 *         """
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival3 = 0
 *         CHKERR( PEPGetDimensions(self.pep, &ival1, &ival2, &ival3) )
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/PEP.pyx":717
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetDimensions(self.pep, &ival1, &ival2, &ival3) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 */
  __pyx_v_ival3 = 0;

  /* "SLEPc/PEP.pyx":718
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 *         CHKERR( PEPGetDimensions(self.pep, &ival1, &ival2, &ival3) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetDimensions(__pyx_v_self->pep, (&__pyx_v_ival1), (&__pyx_v_ival2), (&__pyx_v_ival3))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 718, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":719
 *         cdef PetscInt ival3 = 0
 *         CHKERR( PEPGetDimensions(self.pep, &ival1, &ival2, &ival3) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))             # <<<<<<<<<<<<<<
 * 
 *     def setDimensions(self, nev=None, ncv=None, mpd=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 719, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 719, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival3); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 719, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(19, 719, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":701
 *         CHKERR( PEPSetTrackAll(self.pep, tval) )
 * 
 *     def getDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of eigenvalues to compute and the dimension of
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":721
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 *     def setDimensions(self, nev=None, ncv=None, mpd=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of eigenvalues to compute and the dimension of
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_67setDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_66setDimensions[] = "PEP.setDimensions(self, nev=None, ncv=None, mpd=None)\n\n        Sets the number of eigenvalues to compute and the dimension of\n        the subspace.\n\n        Parameters\n        ----------\n        nev: int, optional\n            Number of eigenvalues to compute.\n        ncv: int, optional\n            Maximum dimension of the subspace to be used by the\n            solver.\n        mpd: int, optional\n            Maximum dimension allowed for the projected problem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_67setDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nev = 0;
  PyObject *__pyx_v_ncv = 0;
  PyObject *__pyx_v_mpd = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setDimensions (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nev,&__pyx_n_s_ncv,&__pyx_n_s_mpd,0};
    PyObject* values[3] = {0,0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nev);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ncv);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mpd);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setDimensions") < 0)) __PYX_ERR(19, 721, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_nev = values[0];
    __pyx_v_ncv = values[1];
    __pyx_v_mpd = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setDimensions", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 721, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_66setDimensions(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_nev, __pyx_v_ncv, __pyx_v_mpd);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_66setDimensions(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_nev, PyObject *__pyx_v_ncv, PyObject *__pyx_v_mpd) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setDimensions", 0);

  /* "SLEPc/PEP.pyx":736
 *             Maximum dimension allowed for the projected problem.
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":737
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":738
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)
 */
  __pyx_v_ival3 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":739
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)             # <<<<<<<<<<<<<<
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)
 */
  __pyx_t_1 = (__pyx_v_nev != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_nev); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 739, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_3;
  }

  /* "SLEPc/PEP.pyx":740
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)             # <<<<<<<<<<<<<<
 *         if mpd is not None: ival3 = asInt(mpd)
 *         CHKERR( PEPSetDimensions(self.pep, ival1, ival2, ival3) )
 */
  __pyx_t_2 = (__pyx_v_ncv != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_ncv); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 740, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_3;
  }

  /* "SLEPc/PEP.pyx":741
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetDimensions(self.pep, ival1, ival2, ival3) )
 * 
 */
  __pyx_t_1 = (__pyx_v_mpd != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_mpd); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 741, __pyx_L1_error)
    __pyx_v_ival3 = __pyx_t_3;
  }

  /* "SLEPc/PEP.pyx":742
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)
 *         CHKERR( PEPSetDimensions(self.pep, ival1, ival2, ival3) )             # <<<<<<<<<<<<<<
 * 
 *     def getST(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetDimensions(__pyx_v_self->pep, __pyx_v_ival1, __pyx_v_ival2, __pyx_v_ival3)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(19, 742, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":721
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 *     def setDimensions(self, nev=None, ncv=None, mpd=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of eigenvalues to compute and the dimension of
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":744
 *         CHKERR( PEPSetDimensions(self.pep, ival1, ival2, ival3) )
 * 
 *     def getST(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the spectral transformation (`ST`) object associated to
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_69getST(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_68getST[] = "PEP.getST(self)\n\n        Obtain the spectral transformation (`ST`) object associated to\n        the eigensolver object.\n\n        Returns\n        -------\n        st: ST\n            The spectral transformation.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_69getST(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getST (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getST", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getST", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_68getST(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_68getST(struct PySlepcPEPObject *__pyx_v_self) {
  struct PySlepcSTObject *__pyx_v_st = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getST", 0);

  /* "SLEPc/PEP.pyx":754
 *             The spectral transformation.
 *         """
 *         cdef ST st = ST()             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetST(self.pep, &st.st) )
 *         PetscINCREF(st.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_ST)); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 754, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_st = ((struct PySlepcSTObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":755
 *         """
 *         cdef ST st = ST()
 *         CHKERR( PEPGetST(self.pep, &st.st) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(st.obj)
 *         return st
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetST(__pyx_v_self->pep, (&__pyx_v_st->st))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 755, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":756
 *         cdef ST st = ST()
 *         CHKERR( PEPGetST(self.pep, &st.st) )
 *         PetscINCREF(st.obj)             # <<<<<<<<<<<<<<
 *         return st
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_st->__pyx_base.obj));

  /* "SLEPc/PEP.pyx":757
 *         CHKERR( PEPGetST(self.pep, &st.st) )
 *         PetscINCREF(st.obj)
 *         return st             # <<<<<<<<<<<<<<
 * 
 *     def setST(self, ST st):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_st));
  __pyx_r = ((PyObject *)__pyx_v_st);
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":744
 *         CHKERR( PEPSetDimensions(self.pep, ival1, ival2, ival3) )
 * 
 *     def getST(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the spectral transformation (`ST`) object associated to
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getST", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_st);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":759
 *         return st
 * 
 *     def setST(self, ST st):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a spectral transformation object to the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_71setST(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_70setST[] = "PEP.setST(self, ST st)\n\n        Associates a spectral transformation object to the\n        eigensolver.\n\n        Parameters\n        ----------\n        st: ST\n            The spectral transformation.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_71setST(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcSTObject *__pyx_v_st = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setST (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_st,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_st)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setST") < 0)) __PYX_ERR(19, 759, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_st = ((struct PySlepcSTObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setST", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 759, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setST", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_st), __pyx_ptype_8slepc4py_5SLEPc_ST, 0, "st", 0))) __PYX_ERR(19, 759, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_70setST(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_st);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_70setST(struct PySlepcPEPObject *__pyx_v_self, struct PySlepcSTObject *__pyx_v_st) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setST", 0);

  /* "SLEPc/PEP.pyx":769
 *             The spectral transformation.
 *         """
 *         CHKERR( PEPSetST(self.pep, st.st) )             # <<<<<<<<<<<<<<
 * 
 *     def getScale(self, Vec Dl=None, Vec Dr=None):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetST(__pyx_v_self->pep, __pyx_v_st->st)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 769, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":759
 *         return st
 * 
 *     def setST(self, ST st):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a spectral transformation object to the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setST", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":771
 *         CHKERR( PEPSetST(self.pep, st.st) )
 * 
 *     def getScale(self, Vec Dl=None, Vec Dr=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the strategy used for scaling the polynomial eigenproblem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_73getScale(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_72getScale[] = "PEP.getScale(self, Vec Dl=None, Vec Dr=None)\n\n        Gets the strategy used for scaling the polynomial eigenproblem.\n\n        Parameters\n        ----------\n        Dl: Vec, optional\n            Placeholder for the returned left diagonal matrix.\n        Dr: Vec, optional\n            Placeholder for the returned right diagonal matrix.\n\n        Returns\n        -------\n        scale: `PEP.Scale` enumerate\n            The scaling strategy.\n        alpha: real\n            The scaling factor.\n        its: int\n            The number of iteration of diagonal scaling.\n        lbda: real\n            Approximation of the wanted eigenvalues (modulus).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_73getScale(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscVecObject *__pyx_v_Dl = 0;
  struct PyPetscVecObject *__pyx_v_Dr = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getScale (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Dl,&__pyx_n_s_Dr,0};
    PyObject* values[2] = {0,0};
    values[0] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    values[1] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Dl);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Dr);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getScale") < 0)) __PYX_ERR(19, 771, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_Dl = ((struct PyPetscVecObject *)values[0]);
    __pyx_v_Dr = ((struct PyPetscVecObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getScale", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 771, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getScale", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Dl), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "Dl", 0))) __PYX_ERR(19, 771, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Dr), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "Dr", 0))) __PYX_ERR(19, 771, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_72getScale(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_Dl, __pyx_v_Dr);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_72getScale(struct PySlepcPEPObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_Dl, struct PyPetscVecObject *__pyx_v_Dr) {
  PEPScale __pyx_v_scale;
  PetscReal __pyx_v_alpha;
  PetscInt __pyx_v_its;
  PetscReal __pyx_v_lbda;
  Vec __pyx_v_vecl;
  Vec __pyx_v_vecr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getScale", 0);

  /* "SLEPc/PEP.pyx":793
 *             Approximation of the wanted eigenvalues (modulus).
 *         """
 *         cdef SlepcPEPScale scale = PEP_SCALE_NONE             # <<<<<<<<<<<<<<
 *         cdef PetscReal alpha = 0
 *         cdef PetscInt its = 0
 */
  __pyx_v_scale = PEP_SCALE_NONE;

  /* "SLEPc/PEP.pyx":794
 *         """
 *         cdef SlepcPEPScale scale = PEP_SCALE_NONE
 *         cdef PetscReal alpha = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt its = 0
 *         cdef PetscReal lbda = 0
 */
  __pyx_v_alpha = 0.0;

  /* "SLEPc/PEP.pyx":795
 *         cdef SlepcPEPScale scale = PEP_SCALE_NONE
 *         cdef PetscReal alpha = 0
 *         cdef PetscInt its = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal lbda = 0
 *         cdef PetscVec vecl = NULL
 */
  __pyx_v_its = 0;

  /* "SLEPc/PEP.pyx":796
 *         cdef PetscReal alpha = 0
 *         cdef PetscInt its = 0
 *         cdef PetscReal lbda = 0             # <<<<<<<<<<<<<<
 *         cdef PetscVec vecl = NULL
 *         cdef PetscVec vecr = NULL
 */
  __pyx_v_lbda = 0.0;

  /* "SLEPc/PEP.pyx":797
 *         cdef PetscInt its = 0
 *         cdef PetscReal lbda = 0
 *         cdef PetscVec vecl = NULL             # <<<<<<<<<<<<<<
 *         cdef PetscVec vecr = NULL
 *         CHKERR( PEPGetScale(self.pep, &scale, &alpha, &vecl, &vecr, &its, &lbda) )
 */
  __pyx_v_vecl = NULL;

  /* "SLEPc/PEP.pyx":798
 *         cdef PetscReal lbda = 0
 *         cdef PetscVec vecl = NULL
 *         cdef PetscVec vecr = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetScale(self.pep, &scale, &alpha, &vecl, &vecr, &its, &lbda) )
 *         if Dl.vec != NULL:
 */
  __pyx_v_vecr = NULL;

  /* "SLEPc/PEP.pyx":799
 *         cdef PetscVec vecl = NULL
 *         cdef PetscVec vecr = NULL
 *         CHKERR( PEPGetScale(self.pep, &scale, &alpha, &vecl, &vecr, &its, &lbda) )             # <<<<<<<<<<<<<<
 *         if Dl.vec != NULL:
 *             if vecl != NULL:
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetScale(__pyx_v_self->pep, (&__pyx_v_scale), (&__pyx_v_alpha), (&__pyx_v_vecl), (&__pyx_v_vecr), (&__pyx_v_its), (&__pyx_v_lbda))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 799, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":800
 *         cdef PetscVec vecr = NULL
 *         CHKERR( PEPGetScale(self.pep, &scale, &alpha, &vecl, &vecr, &its, &lbda) )
 *         if Dl.vec != NULL:             # <<<<<<<<<<<<<<
 *             if vecl != NULL:
 *                 CHKERR( VecCopy(vecl, Dl.vec) )
 */
  __pyx_t_2 = ((__pyx_v_Dl->vec != NULL) != 0);
  if (__pyx_t_2) {

    /* "SLEPc/PEP.pyx":801
 *         CHKERR( PEPGetScale(self.pep, &scale, &alpha, &vecl, &vecr, &its, &lbda) )
 *         if Dl.vec != NULL:
 *             if vecl != NULL:             # <<<<<<<<<<<<<<
 *                 CHKERR( VecCopy(vecl, Dl.vec) )
 *             else:
 */
    __pyx_t_2 = ((__pyx_v_vecl != NULL) != 0);
    if (__pyx_t_2) {

      /* "SLEPc/PEP.pyx":802
 *         if Dl.vec != NULL:
 *             if vecl != NULL:
 *                 CHKERR( VecCopy(vecl, Dl.vec) )             # <<<<<<<<<<<<<<
 *             else:
 *                 CHKERR( VecSet(Dl.vec, 1.0) )
 */
      __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(VecCopy(__pyx_v_vecl, __pyx_v_Dl->vec)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 802, __pyx_L1_error)

      /* "SLEPc/PEP.pyx":801
 *         CHKERR( PEPGetScale(self.pep, &scale, &alpha, &vecl, &vecr, &its, &lbda) )
 *         if Dl.vec != NULL:
 *             if vecl != NULL:             # <<<<<<<<<<<<<<
 *                 CHKERR( VecCopy(vecl, Dl.vec) )
 *             else:
 */
      goto __pyx_L4;
    }

    /* "SLEPc/PEP.pyx":804
 *                 CHKERR( VecCopy(vecl, Dl.vec) )
 *             else:
 *                 CHKERR( VecSet(Dl.vec, 1.0) )             # <<<<<<<<<<<<<<
 *         if Dr.vec != NULL:
 *             if vecr != NULL:
 */
    /*else*/ {
      __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(VecSet(__pyx_v_Dl->vec, 1.0)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 804, __pyx_L1_error)
    }
    __pyx_L4:;

    /* "SLEPc/PEP.pyx":800
 *         cdef PetscVec vecr = NULL
 *         CHKERR( PEPGetScale(self.pep, &scale, &alpha, &vecl, &vecr, &its, &lbda) )
 *         if Dl.vec != NULL:             # <<<<<<<<<<<<<<
 *             if vecl != NULL:
 *                 CHKERR( VecCopy(vecl, Dl.vec) )
 */
  }

  /* "SLEPc/PEP.pyx":805
 *             else:
 *                 CHKERR( VecSet(Dl.vec, 1.0) )
 *         if Dr.vec != NULL:             # <<<<<<<<<<<<<<
 *             if vecr != NULL:
 *                 CHKERR( VecCopy(vecr, Dr.vec) )
 */
  __pyx_t_2 = ((__pyx_v_Dr->vec != NULL) != 0);
  if (__pyx_t_2) {

    /* "SLEPc/PEP.pyx":806
 *                 CHKERR( VecSet(Dl.vec, 1.0) )
 *         if Dr.vec != NULL:
 *             if vecr != NULL:             # <<<<<<<<<<<<<<
 *                 CHKERR( VecCopy(vecr, Dr.vec) )
 *             else:
 */
    __pyx_t_2 = ((__pyx_v_vecr != NULL) != 0);
    if (__pyx_t_2) {

      /* "SLEPc/PEP.pyx":807
 *         if Dr.vec != NULL:
 *             if vecr != NULL:
 *                 CHKERR( VecCopy(vecr, Dr.vec) )             # <<<<<<<<<<<<<<
 *             else:
 *                 CHKERR( VecSet(Dr.vec, 1.0) )
 */
      __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(VecCopy(__pyx_v_vecr, __pyx_v_Dr->vec)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 807, __pyx_L1_error)

      /* "SLEPc/PEP.pyx":806
 *                 CHKERR( VecSet(Dl.vec, 1.0) )
 *         if Dr.vec != NULL:
 *             if vecr != NULL:             # <<<<<<<<<<<<<<
 *                 CHKERR( VecCopy(vecr, Dr.vec) )
 *             else:
 */
      goto __pyx_L6;
    }

    /* "SLEPc/PEP.pyx":809
 *                 CHKERR( VecCopy(vecr, Dr.vec) )
 *             else:
 *                 CHKERR( VecSet(Dr.vec, 1.0) )             # <<<<<<<<<<<<<<
 *         CHKERR( VecDestroy(&vecl) )
 *         CHKERR( VecDestroy(&vecr) )
 */
    /*else*/ {
      __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(VecSet(__pyx_v_Dr->vec, 1.0)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 809, __pyx_L1_error)
    }
    __pyx_L6:;

    /* "SLEPc/PEP.pyx":805
 *             else:
 *                 CHKERR( VecSet(Dl.vec, 1.0) )
 *         if Dr.vec != NULL:             # <<<<<<<<<<<<<<
 *             if vecr != NULL:
 *                 CHKERR( VecCopy(vecr, Dr.vec) )
 */
  }

  /* "SLEPc/PEP.pyx":810
 *             else:
 *                 CHKERR( VecSet(Dr.vec, 1.0) )
 *         CHKERR( VecDestroy(&vecl) )             # <<<<<<<<<<<<<<
 *         CHKERR( VecDestroy(&vecr) )
 *         return (scale, toReal(alpha), toInt(its), toReal(lbda))
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(VecDestroy((&__pyx_v_vecl))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 810, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":811
 *                 CHKERR( VecSet(Dr.vec, 1.0) )
 *         CHKERR( VecDestroy(&vecl) )
 *         CHKERR( VecDestroy(&vecr) )             # <<<<<<<<<<<<<<
 *         return (scale, toReal(alpha), toInt(its), toReal(lbda))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(VecDestroy((&__pyx_v_vecr))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 811, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":812
 *         CHKERR( VecDestroy(&vecl) )
 *         CHKERR( VecDestroy(&vecr) )
 *         return (scale, toReal(alpha), toInt(its), toReal(lbda))             # <<<<<<<<<<<<<<
 * 
 *     def setScale(self, scale, alpha=None, Vec Dl=None, Vec Dr=None, its=None, lbda=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = __Pyx_PyInt_From_PEPScale(__pyx_v_scale); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 812, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_alpha); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 812, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_its); if (unlikely(!__pyx_t_5)) __PYX_ERR(19, 812, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_lbda); if (unlikely(!__pyx_t_6)) __PYX_ERR(19, 812, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(19, 812, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_6);
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_t_6 = 0;
  __pyx_r = __pyx_t_7;
  __pyx_t_7 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":771
 *         CHKERR( PEPSetST(self.pep, st.st) )
 * 
 *     def getScale(self, Vec Dl=None, Vec Dr=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the strategy used for scaling the polynomial eigenproblem.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getScale", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":814
 *         return (scale, toReal(alpha), toInt(its), toReal(lbda))
 * 
 *     def setScale(self, scale, alpha=None, Vec Dl=None, Vec Dr=None, its=None, lbda=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the scaling strategy to be used for scaling the polynomial problem
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_75setScale(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_74setScale[] = "PEP.setScale(self, scale, alpha=None, Vec Dl=None, Vec Dr=None, its=None, lbda=None)\n\n        Sets the scaling strategy to be used for scaling the polynomial problem\n        before attempting to solve.\n\n        Parameters\n        ----------\n        scale: `PEP.Scale` enumerate\n            The scaling strategy.\n        alpha: real, optional\n            The scaling factor.\n        Dl: Vec, optional\n            The left diagonal matrix.\n        Dr: Vec, optional\n            The right diagonal matrix.\n        its: int, optional\n            The number of iteration of diagonal scaling.\n        lbda: real, optional\n            Approximation of the wanted eigenvalues (modulus).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_75setScale(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_scale = 0;
  PyObject *__pyx_v_alpha = 0;
  struct PyPetscVecObject *__pyx_v_Dl = 0;
  struct PyPetscVecObject *__pyx_v_Dr = 0;
  PyObject *__pyx_v_its = 0;
  PyObject *__pyx_v_lbda = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setScale (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_scale,&__pyx_n_s_alpha,&__pyx_n_s_Dl,&__pyx_n_s_Dr,&__pyx_n_s_its,&__pyx_n_s_lbda,0};
    PyObject* values[6] = {0,0,0,0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    values[3] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    values[4] = ((PyObject *)Py_None);
    values[5] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_scale)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Dl);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Dr);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_its);
          if (value) { values[4] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lbda);
          if (value) { values[5] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setScale") < 0)) __PYX_ERR(19, 814, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_scale = values[0];
    __pyx_v_alpha = values[1];
    __pyx_v_Dl = ((struct PyPetscVecObject *)values[2]);
    __pyx_v_Dr = ((struct PyPetscVecObject *)values[3]);
    __pyx_v_its = values[4];
    __pyx_v_lbda = values[5];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setScale", 0, 1, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 814, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setScale", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Dl), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "Dl", 0))) __PYX_ERR(19, 814, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Dr), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "Dr", 0))) __PYX_ERR(19, 814, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_74setScale(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_scale, __pyx_v_alpha, __pyx_v_Dl, __pyx_v_Dr, __pyx_v_its, __pyx_v_lbda);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_74setScale(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_scale, PyObject *__pyx_v_alpha, struct PyPetscVecObject *__pyx_v_Dl, struct PyPetscVecObject *__pyx_v_Dr, PyObject *__pyx_v_its, PyObject *__pyx_v_lbda) {
  PEPScale __pyx_v_senum;
  PetscReal __pyx_v_rval1;
  PetscInt __pyx_v_ival;
  PetscReal __pyx_v_rval2;
  Vec __pyx_v_vecl;
  Vec __pyx_v_vecr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PEPScale __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PetscReal __pyx_t_4;
  Vec __pyx_t_5;
  PetscInt __pyx_t_6;
  int __pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setScale", 0);

  /* "SLEPc/PEP.pyx":834
 *             Approximation of the wanted eigenvalues (modulus).
 *         """
 *         cdef SlepcPEPScale senum = scale             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval1 = PETSC_DEFAULT
 *         cdef PetscInt ival = PETSC_DEFAULT
 */
  __pyx_t_1 = ((PEPScale)__Pyx_PyInt_As_PEPScale(__pyx_v_scale)); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 834, __pyx_L1_error)
  __pyx_v_senum = __pyx_t_1;

  /* "SLEPc/PEP.pyx":835
 *         """
 *         cdef SlepcPEPScale senum = scale
 *         cdef PetscReal rval1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival = PETSC_DEFAULT
 *         cdef PetscReal rval2 = PETSC_DEFAULT
 */
  __pyx_v_rval1 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":836
 *         cdef SlepcPEPScale senum = scale
 *         cdef PetscReal rval1 = PETSC_DEFAULT
 *         cdef PetscInt ival = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval2 = PETSC_DEFAULT
 *         cdef PetscVec vecl = NULL
 */
  __pyx_v_ival = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":837
 *         cdef PetscReal rval1 = PETSC_DEFAULT
 *         cdef PetscInt ival = PETSC_DEFAULT
 *         cdef PetscReal rval2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscVec vecl = NULL
 *         cdef PetscVec vecr = NULL
 */
  __pyx_v_rval2 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":838
 *         cdef PetscInt ival = PETSC_DEFAULT
 *         cdef PetscReal rval2 = PETSC_DEFAULT
 *         cdef PetscVec vecl = NULL             # <<<<<<<<<<<<<<
 *         cdef PetscVec vecr = NULL
 *         if alpha is not None: rval1 = asReal(alpha)
 */
  __pyx_v_vecl = NULL;

  /* "SLEPc/PEP.pyx":839
 *         cdef PetscReal rval2 = PETSC_DEFAULT
 *         cdef PetscVec vecl = NULL
 *         cdef PetscVec vecr = NULL             # <<<<<<<<<<<<<<
 *         if alpha is not None: rval1 = asReal(alpha)
 *         if Dl is not None:    vecl = Dl.vec
 */
  __pyx_v_vecr = NULL;

  /* "SLEPc/PEP.pyx":840
 *         cdef PetscVec vecl = NULL
 *         cdef PetscVec vecr = NULL
 *         if alpha is not None: rval1 = asReal(alpha)             # <<<<<<<<<<<<<<
 *         if Dl is not None:    vecl = Dl.vec
 *         if Dr is not None:    vecr = Dr.vec
 */
  __pyx_t_2 = (__pyx_v_alpha != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_alpha); if (unlikely(__pyx_t_4 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 840, __pyx_L1_error)
    __pyx_v_rval1 = __pyx_t_4;
  }

  /* "SLEPc/PEP.pyx":841
 *         cdef PetscVec vecr = NULL
 *         if alpha is not None: rval1 = asReal(alpha)
 *         if Dl is not None:    vecl = Dl.vec             # <<<<<<<<<<<<<<
 *         if Dr is not None:    vecr = Dr.vec
 *         if its is not None:   ival = asInt(its)
 */
  __pyx_t_3 = (((PyObject *)__pyx_v_Dl) != Py_None);
  __pyx_t_2 = (__pyx_t_3 != 0);
  if (__pyx_t_2) {
    __pyx_t_5 = __pyx_v_Dl->vec;
    __pyx_v_vecl = __pyx_t_5;
  }

  /* "SLEPc/PEP.pyx":842
 *         if alpha is not None: rval1 = asReal(alpha)
 *         if Dl is not None:    vecl = Dl.vec
 *         if Dr is not None:    vecr = Dr.vec             # <<<<<<<<<<<<<<
 *         if its is not None:   ival = asInt(its)
 *         if lbda is not None:  rval2 = asReal(lbda)
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_Dr) != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_5 = __pyx_v_Dr->vec;
    __pyx_v_vecr = __pyx_t_5;
  }

  /* "SLEPc/PEP.pyx":843
 *         if Dl is not None:    vecl = Dl.vec
 *         if Dr is not None:    vecr = Dr.vec
 *         if its is not None:   ival = asInt(its)             # <<<<<<<<<<<<<<
 *         if lbda is not None:  rval2 = asReal(lbda)
 *         CHKERR( PEPSetScale(self.pep, senum, rval1, vecl, vecr, ival, rval2) )
 */
  __pyx_t_3 = (__pyx_v_its != Py_None);
  __pyx_t_2 = (__pyx_t_3 != 0);
  if (__pyx_t_2) {
    __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_its); if (unlikely(__pyx_t_6 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 843, __pyx_L1_error)
    __pyx_v_ival = __pyx_t_6;
  }

  /* "SLEPc/PEP.pyx":844
 *         if Dr is not None:    vecr = Dr.vec
 *         if its is not None:   ival = asInt(its)
 *         if lbda is not None:  rval2 = asReal(lbda)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetScale(self.pep, senum, rval1, vecl, vecr, ival, rval2) )
 * 
 */
  __pyx_t_2 = (__pyx_v_lbda != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_lbda); if (unlikely(__pyx_t_4 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 844, __pyx_L1_error)
    __pyx_v_rval2 = __pyx_t_4;
  }

  /* "SLEPc/PEP.pyx":845
 *         if its is not None:   ival = asInt(its)
 *         if lbda is not None:  rval2 = asReal(lbda)
 *         CHKERR( PEPSetScale(self.pep, senum, rval1, vecl, vecr, ival, rval2) )             # <<<<<<<<<<<<<<
 * 
 *     def getBV(self):
 */
  __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetScale(__pyx_v_self->pep, __pyx_v_senum, __pyx_v_rval1, __pyx_v_vecl, __pyx_v_vecr, __pyx_v_ival, __pyx_v_rval2)); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(19, 845, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":814
 *         return (scale, toReal(alpha), toInt(its), toReal(lbda))
 * 
 *     def setScale(self, scale, alpha=None, Vec Dl=None, Vec Dr=None, its=None, lbda=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the scaling strategy to be used for scaling the polynomial problem
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setScale", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":847
 *         CHKERR( PEPSetScale(self.pep, senum, rval1, vecl, vecr, ival, rval2) )
 * 
 *     def getBV(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the basis vectors object associated to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_77getBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_76getBV[] = "PEP.getBV(self)\n\n        Obtain the basis vectors object associated to the eigensolver.\n\n        Returns\n        -------\n        bv: BV\n            The basis vectors context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_77getBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getBV (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getBV", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBV", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_76getBV(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_76getBV(struct PySlepcPEPObject *__pyx_v_self) {
  struct PySlepcBVObject *__pyx_v_bv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getBV", 0);

  /* "SLEPc/PEP.pyx":856
 *             The basis vectors context.
 *         """
 *         cdef BV bv = BV()             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetBV(self.pep, &bv.bv) )
 *         PetscINCREF(bv.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV)); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 856, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_bv = ((struct PySlepcBVObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":857
 *         """
 *         cdef BV bv = BV()
 *         CHKERR( PEPGetBV(self.pep, &bv.bv) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(bv.obj)
 *         return bv
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetBV(__pyx_v_self->pep, (&__pyx_v_bv->bv))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 857, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":858
 *         cdef BV bv = BV()
 *         CHKERR( PEPGetBV(self.pep, &bv.bv) )
 *         PetscINCREF(bv.obj)             # <<<<<<<<<<<<<<
 *         return bv
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_bv->__pyx_base.obj));

  /* "SLEPc/PEP.pyx":859
 *         CHKERR( PEPGetBV(self.pep, &bv.bv) )
 *         PetscINCREF(bv.obj)
 *         return bv             # <<<<<<<<<<<<<<
 * 
 *     def setBV(self, BV bv):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_bv));
  __pyx_r = ((PyObject *)__pyx_v_bv);
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":847
 *         CHKERR( PEPSetScale(self.pep, senum, rval1, vecl, vecr, ival, rval2) )
 * 
 *     def getBV(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the basis vectors object associated to the eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_bv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":861
 *         return bv
 * 
 *     def setBV(self, BV bv):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a basis vectors object to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_79setBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_78setBV[] = "PEP.setBV(self, BV bv)\n\n        Associates a basis vectors object to the eigensolver.\n\n        Parameters\n        ----------\n        bv: BV\n            The basis vectors context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_79setBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcBVObject *__pyx_v_bv = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setBV (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bv,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bv)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setBV") < 0)) __PYX_ERR(19, 861, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_bv = ((struct PySlepcBVObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setBV", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 861, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_bv), __pyx_ptype_8slepc4py_5SLEPc_BV, 0, "bv", 0))) __PYX_ERR(19, 861, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_78setBV(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_bv);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_78setBV(struct PySlepcPEPObject *__pyx_v_self, struct PySlepcBVObject *__pyx_v_bv) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setBV", 0);

  /* "SLEPc/PEP.pyx":870
 *             The basis vectors context.
 *         """
 *         CHKERR( PEPSetBV(self.pep, bv.bv) )             # <<<<<<<<<<<<<<
 * 
 *     def getRG(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetBV(__pyx_v_self->pep, __pyx_v_bv->bv)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 870, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":861
 *         return bv
 * 
 *     def setBV(self, BV bv):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a basis vectors object to the eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":872
 *         CHKERR( PEPSetBV(self.pep, bv.bv) )
 * 
 *     def getRG(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the region object associated to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_81getRG(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_80getRG[] = "PEP.getRG(self)\n\n        Obtain the region object associated to the eigensolver.\n\n        Returns\n        -------\n        rg: RG\n            The region context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_81getRG(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRG (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRG", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRG", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_80getRG(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_80getRG(struct PySlepcPEPObject *__pyx_v_self) {
  struct PySlepcRGObject *__pyx_v_rg = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRG", 0);

  /* "SLEPc/PEP.pyx":881
 *             The region context.
 *         """
 *         cdef RG rg = RG()             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetRG(self.pep, &rg.rg) )
 *         PetscINCREF(rg.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_RG)); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 881, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_rg = ((struct PySlepcRGObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":882
 *         """
 *         cdef RG rg = RG()
 *         CHKERR( PEPGetRG(self.pep, &rg.rg) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(rg.obj)
 *         return rg
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetRG(__pyx_v_self->pep, (&__pyx_v_rg->rg))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 882, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":883
 *         cdef RG rg = RG()
 *         CHKERR( PEPGetRG(self.pep, &rg.rg) )
 *         PetscINCREF(rg.obj)             # <<<<<<<<<<<<<<
 *         return rg
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_rg->__pyx_base.obj));

  /* "SLEPc/PEP.pyx":884
 *         CHKERR( PEPGetRG(self.pep, &rg.rg) )
 *         PetscINCREF(rg.obj)
 *         return rg             # <<<<<<<<<<<<<<
 * 
 *     def setRG(self, RG rg):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_rg));
  __pyx_r = ((PyObject *)__pyx_v_rg);
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":872
 *         CHKERR( PEPSetBV(self.pep, bv.bv) )
 * 
 *     def getRG(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the region object associated to the eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getRG", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_rg);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":886
 *         return rg
 * 
 *     def setRG(self, RG rg):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a region object to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_83setRG(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_82setRG[] = "PEP.setRG(self, RG rg)\n\n        Associates a region object to the eigensolver.\n\n        Parameters\n        ----------\n        rg: RG\n            The region context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_83setRG(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcRGObject *__pyx_v_rg = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRG (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rg,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rg)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRG") < 0)) __PYX_ERR(19, 886, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_rg = ((struct PySlepcRGObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRG", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 886, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setRG", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rg), __pyx_ptype_8slepc4py_5SLEPc_RG, 0, "rg", 0))) __PYX_ERR(19, 886, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_82setRG(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_rg);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_82setRG(struct PySlepcPEPObject *__pyx_v_self, struct PySlepcRGObject *__pyx_v_rg) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRG", 0);

  /* "SLEPc/PEP.pyx":895
 *             The region context.
 *         """
 *         CHKERR( PEPSetRG(self.pep, rg.rg) )             # <<<<<<<<<<<<<<
 * 
 *     def getDS(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetRG(__pyx_v_self->pep, __pyx_v_rg->rg)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 895, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":886
 *         return rg
 * 
 *     def setRG(self, RG rg):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a region object to the eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setRG", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":897
 *         CHKERR( PEPSetRG(self.pep, rg.rg) )
 * 
 *     def getDS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the direct solver associated to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_85getDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_84getDS[] = "PEP.getDS(self)\n\n        Obtain the direct solver associated to the eigensolver.\n\n        Returns\n        -------\n        ds: DS\n            The direct solver context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_85getDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDS (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getDS", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDS", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_84getDS(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_84getDS(struct PySlepcPEPObject *__pyx_v_self) {
  struct PySlepcDSObject *__pyx_v_ds = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getDS", 0);

  /* "SLEPc/PEP.pyx":906
 *             The direct solver context.
 *         """
 *         cdef DS ds = DS()             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetDS(self.pep, &ds.ds) )
 *         PetscINCREF(ds.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_DS)); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 906, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ds = ((struct PySlepcDSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":907
 *         """
 *         cdef DS ds = DS()
 *         CHKERR( PEPGetDS(self.pep, &ds.ds) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(ds.obj)
 *         return ds
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetDS(__pyx_v_self->pep, (&__pyx_v_ds->ds))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 907, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":908
 *         cdef DS ds = DS()
 *         CHKERR( PEPGetDS(self.pep, &ds.ds) )
 *         PetscINCREF(ds.obj)             # <<<<<<<<<<<<<<
 *         return ds
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ds->__pyx_base.obj));

  /* "SLEPc/PEP.pyx":909
 *         CHKERR( PEPGetDS(self.pep, &ds.ds) )
 *         PetscINCREF(ds.obj)
 *         return ds             # <<<<<<<<<<<<<<
 * 
 *     def setDS(self, DS ds):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ds));
  __pyx_r = ((PyObject *)__pyx_v_ds);
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":897
 *         CHKERR( PEPSetRG(self.pep, rg.rg) )
 * 
 *     def getDS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the direct solver associated to the eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ds);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":911
 *         return ds
 * 
 *     def setDS(self, DS ds):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a direct solver object to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_87setDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_86setDS[] = "PEP.setDS(self, DS ds)\n\n        Associates a direct solver object to the eigensolver.\n\n        Parameters\n        ----------\n        ds: DS\n            The direct solver context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_87setDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcDSObject *__pyx_v_ds = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setDS (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ds,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ds)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setDS") < 0)) __PYX_ERR(19, 911, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_ds = ((struct PySlepcDSObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setDS", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 911, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ds), __pyx_ptype_8slepc4py_5SLEPc_DS, 0, "ds", 0))) __PYX_ERR(19, 911, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_86setDS(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_ds);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_86setDS(struct PySlepcPEPObject *__pyx_v_self, struct PySlepcDSObject *__pyx_v_ds) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setDS", 0);

  /* "SLEPc/PEP.pyx":920
 *             The direct solver context.
 *         """
 *         CHKERR( PEPSetDS(self.pep, ds.ds) )             # <<<<<<<<<<<<<<
 * 
 *     def getOperators(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetDS(__pyx_v_self->pep, __pyx_v_ds->ds)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 920, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":911
 *         return ds
 * 
 *     def setDS(self, DS ds):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a direct solver object to the eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":922
 *         CHKERR( PEPSetDS(self.pep, ds.ds) )
 * 
 *     def getOperators(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the matrices associated with the eigenvalue problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_89getOperators(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_88getOperators[] = "PEP.getOperators(self)\n\n        Gets the matrices associated with the eigenvalue problem.\n\n        Returns\n        -------\n        operators: tuple of Mat\n           The matrices associated with the eigensystem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_89getOperators(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOperators (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOperators", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOperators", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_88getOperators(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_88getOperators(struct PySlepcPEPObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  Mat __pyx_v_mat;
  PetscInt __pyx_v_k;
  PetscInt __pyx_v_n;
  PyObject *__pyx_v_operators = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOperators", 0);

  /* "SLEPc/PEP.pyx":932
 *         """
 *         cdef Mat A
 *         cdef PetscMat mat = NULL             # <<<<<<<<<<<<<<
 *         cdef PetscInt k=0, n=0
 *         CHKERR( PEPGetNumMatrices(self.pep, &n) )
 */
  __pyx_v_mat = NULL;

  /* "SLEPc/PEP.pyx":933
 *         cdef Mat A
 *         cdef PetscMat mat = NULL
 *         cdef PetscInt k=0, n=0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetNumMatrices(self.pep, &n) )
 *         cdef object operators = []
 */
  __pyx_v_k = 0;
  __pyx_v_n = 0;

  /* "SLEPc/PEP.pyx":934
 *         cdef PetscMat mat = NULL
 *         cdef PetscInt k=0, n=0
 *         CHKERR( PEPGetNumMatrices(self.pep, &n) )             # <<<<<<<<<<<<<<
 *         cdef object operators = []
 *         for k from 0 <= k < n:
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetNumMatrices(__pyx_v_self->pep, (&__pyx_v_n))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 934, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":935
 *         cdef PetscInt k=0, n=0
 *         CHKERR( PEPGetNumMatrices(self.pep, &n) )
 *         cdef object operators = []             # <<<<<<<<<<<<<<
 *         for k from 0 <= k < n:
 *             CHKERR( PEPGetOperators(self.pep, k, &mat) )
 */
  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 935, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_operators = __pyx_t_2;
  __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":936
 *         CHKERR( PEPGetNumMatrices(self.pep, &n) )
 *         cdef object operators = []
 *         for k from 0 <= k < n:             # <<<<<<<<<<<<<<
 *             CHKERR( PEPGetOperators(self.pep, k, &mat) )
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)
 */
  __pyx_t_3 = __pyx_v_n;
  for (__pyx_v_k = 0; __pyx_v_k < __pyx_t_3; __pyx_v_k++) {

    /* "SLEPc/PEP.pyx":937
 *         cdef object operators = []
 *         for k from 0 <= k < n:
 *             CHKERR( PEPGetOperators(self.pep, k, &mat) )             # <<<<<<<<<<<<<<
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)
 *             operators.append(A)
 */
    __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetOperators(__pyx_v_self->pep, __pyx_v_k, (&__pyx_v_mat))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 937, __pyx_L1_error)

    /* "SLEPc/PEP.pyx":938
 *         for k from 0 <= k < n:
 *             CHKERR( PEPGetOperators(self.pep, k, &mat) )
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)             # <<<<<<<<<<<<<<
 *             operators.append(A)
 *         return tuple(operators)
 */
    __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 938, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_A, ((struct PyPetscMatObject *)__pyx_t_2));
    __pyx_t_2 = 0;
    __pyx_v_A->mat = __pyx_v_mat;
    (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_A->__pyx_base.obj));

    /* "SLEPc/PEP.pyx":939
 *             CHKERR( PEPGetOperators(self.pep, k, &mat) )
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)
 *             operators.append(A)             # <<<<<<<<<<<<<<
 *         return tuple(operators)
 * 
 */
    __pyx_t_4 = __Pyx_PyObject_Append(__pyx_v_operators, ((PyObject *)__pyx_v_A)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(19, 939, __pyx_L1_error)
  }

  /* "SLEPc/PEP.pyx":940
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)
 *             operators.append(A)
 *         return tuple(operators)             # <<<<<<<<<<<<<<
 * 
 *     def setOperators(self, operators):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_v_operators); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 940, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":922
 *         CHKERR( PEPSetDS(self.pep, ds.ds) )
 * 
 *     def getOperators(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the matrices associated with the eigenvalue problem.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getOperators", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_A);
  __Pyx_XDECREF(__pyx_v_operators);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":942
 *         return tuple(operators)
 * 
 *     def setOperators(self, operators):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the matrices associated with the eigenvalue problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_91setOperators(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_90setOperators[] = "PEP.setOperators(self, operators)\n\n        Sets the matrices associated with the eigenvalue problem.\n\n        Parameters\n        ----------\n        operators: sequence of Mat\n           The matrices associated with the eigensystem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_91setOperators(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_operators = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOperators (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_operators,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_operators)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOperators") < 0)) __PYX_ERR(19, 942, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_operators = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOperators", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 942, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setOperators", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_90setOperators(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_operators);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_90setOperators(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_operators) {
  Mat *__pyx_v_mats;
  Py_ssize_t __pyx_v_k;
  Py_ssize_t __pyx_v_n;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  Py_ssize_t __pyx_t_2;
  Mat __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOperators", 0);
  __Pyx_INCREF(__pyx_v_operators);

  /* "SLEPc/PEP.pyx":951
 *            The matrices associated with the eigensystem.
 *         """
 *         operators = tuple(operators)             # <<<<<<<<<<<<<<
 *         cdef PetscMat *mats = NULL
 *         cdef Py_ssize_t k=0, n = len(operators)
 */
  __pyx_t_1 = __Pyx_PySequence_Tuple(__pyx_v_operators); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 951, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_operators, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":952
 *         """
 *         operators = tuple(operators)
 *         cdef PetscMat *mats = NULL             # <<<<<<<<<<<<<<
 *         cdef Py_ssize_t k=0, n = len(operators)
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscMat),<void**>&mats)
 */
  __pyx_v_mats = NULL;

  /* "SLEPc/PEP.pyx":953
 *         operators = tuple(operators)
 *         cdef PetscMat *mats = NULL
 *         cdef Py_ssize_t k=0, n = len(operators)             # <<<<<<<<<<<<<<
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscMat),<void**>&mats)
 *         for k from 0 <= k < n: mats[k] = (<Mat?>operators[k]).mat
 */
  __pyx_v_k = 0;
  __pyx_t_2 = PyObject_Length(__pyx_v_operators); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(19, 953, __pyx_L1_error)
  __pyx_v_n = __pyx_t_2;

  /* "SLEPc/PEP.pyx":954
 *         cdef PetscMat *mats = NULL
 *         cdef Py_ssize_t k=0, n = len(operators)
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscMat),<void**>&mats)             # <<<<<<<<<<<<<<
 *         for k from 0 <= k < n: mats[k] = (<Mat?>operators[k]).mat
 *         CHKERR( PEPSetOperators(self.pep, <PetscInt>n, mats) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_n) * (sizeof(Mat))), ((void **)(&__pyx_v_mats))); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 954, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_tmp = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":955
 *         cdef Py_ssize_t k=0, n = len(operators)
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscMat),<void**>&mats)
 *         for k from 0 <= k < n: mats[k] = (<Mat?>operators[k]).mat             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetOperators(self.pep, <PetscInt>n, mats) )
 * 
 */
  __pyx_t_2 = __pyx_v_n;
  for (__pyx_v_k = 0; __pyx_v_k < __pyx_t_2; __pyx_v_k++) {
    __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_operators, __pyx_v_k, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 955, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_8petsc4py_5PETSc_Mat)))) __PYX_ERR(19, 955, __pyx_L1_error)
    __pyx_t_3 = ((struct PyPetscMatObject *)__pyx_t_1)->mat;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    (__pyx_v_mats[__pyx_v_k]) = __pyx_t_3;
  }

  /* "SLEPc/PEP.pyx":956
 *         cdef tmp = allocate(<size_t>n*sizeof(PetscMat),<void**>&mats)
 *         for k from 0 <= k < n: mats[k] = (<Mat?>operators[k]).mat
 *         CHKERR( PEPSetOperators(self.pep, <PetscInt>n, mats) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetOperators(__pyx_v_self->pep, ((PetscInt)__pyx_v_n), __pyx_v_mats)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(19, 956, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":942
 *         return tuple(operators)
 * 
 *     def setOperators(self, operators):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the matrices associated with the eigenvalue problem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setOperators", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XDECREF(__pyx_v_operators);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":960
 *     #
 * 
 *     def setInitialSpace(self, space):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the initial space from which the eigensolver starts to
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_93setInitialSpace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_92setInitialSpace[] = "PEP.setInitialSpace(self, space)\n\n        Sets the initial space from which the eigensolver starts to\n        iterate.\n\n        Parameters\n        ----------\n        space: Vec or sequence of Vec\n           The initial space\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_93setInitialSpace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_space = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setInitialSpace (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_space,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_space)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setInitialSpace") < 0)) __PYX_ERR(19, 960, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_space = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setInitialSpace", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 960, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setInitialSpace", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_92setInitialSpace(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_space);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_92setInitialSpace(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_space) {
  Vec *__pyx_v_vs;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_ns;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  Py_ssize_t __pyx_t_6;
  Vec __pyx_t_7;
  int __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setInitialSpace", 0);
  __Pyx_INCREF(__pyx_v_space);

  /* "SLEPc/PEP.pyx":970
 *            The initial space
 *         """
 *         if isinstance(space, Vec): space = [space]             # <<<<<<<<<<<<<<
 *         cdef PetscVec *vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)
 */
  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_space, __pyx_ptype_8petsc4py_5PETSc_Vec); 
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 970, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_space);
    __Pyx_GIVEREF(__pyx_v_space);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_space);
    __Pyx_DECREF_SET(__pyx_v_space, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/PEP.pyx":971
 *         """
 *         if isinstance(space, Vec): space = [space]
 *         cdef PetscVec *vs = NULL             # <<<<<<<<<<<<<<
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 */
  __pyx_v_vs = NULL;

  /* "SLEPc/PEP.pyx":972
 *         if isinstance(space, Vec): space = [space]
 *         cdef PetscVec *vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)             # <<<<<<<<<<<<<<
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 */
  __pyx_v_i = 0;
  __pyx_t_4 = PyObject_Length(__pyx_v_space); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(19, 972, __pyx_L1_error)
  __pyx_v_ns = __pyx_t_4;

  /* "SLEPc/PEP.pyx":973
 *         cdef PetscVec *vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)             # <<<<<<<<<<<<<<
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 *         CHKERR( PEPSetInitialSpace(self.pep, <PetscInt>ns, vs) )
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_ns) * (sizeof(Vec))), ((void **)(&__pyx_v_vs))); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 973, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/PEP.pyx":974
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSetInitialSpace(self.pep, <PetscInt>ns, vs) )
 * 
 */
  __pyx_t_4 = __pyx_v_ns;
  __pyx_t_5 = __pyx_t_4;
  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
    __pyx_v_i = __pyx_t_6;
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_space, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 974, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8petsc4py_5PETSc_Vec)))) __PYX_ERR(19, 974, __pyx_L1_error)
    __pyx_t_7 = ((struct PyPetscVecObject *)__pyx_t_3)->vec;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    (__pyx_v_vs[__pyx_v_i]) = __pyx_t_7;
  }

  /* "SLEPc/PEP.pyx":975
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 *         CHKERR( PEPSetInitialSpace(self.pep, <PetscInt>ns, vs) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_8 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetInitialSpace(__pyx_v_self->pep, ((PetscInt)__pyx_v_ns), __pyx_v_vs)); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(19, 975, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":960
 *     #
 * 
 *     def setInitialSpace(self, space):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the initial space from which the eigensolver starts to
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setInitialSpace", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XDECREF(__pyx_v_space);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":979
 *     #
 * 
 *     def setStoppingTest(self, stopping, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_95setStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_94setStoppingTest[] = "PEP.setStoppingTest(self, stopping, args=None, kargs=None)\n\n        Sets a function to decide when to stop the outer iteration of the eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_95setStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_stopping = 0;
  PyObject *__pyx_v_args = 0;
  PyObject *__pyx_v_kargs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setStoppingTest (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_stopping,&__pyx_n_s_args,&__pyx_n_s_kargs,0};
    PyObject* values[3] = {0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_stopping)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kargs);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setStoppingTest") < 0)) __PYX_ERR(19, 979, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_stopping = values[0];
    __pyx_v_args = values[1];
    __pyx_v_kargs = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setStoppingTest", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 979, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setStoppingTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_94setStoppingTest(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_stopping, __pyx_v_args, __pyx_v_kargs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_94setStoppingTest(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_stopping, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setStoppingTest", 0);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);

  /* "SLEPc/PEP.pyx":983
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 *         """
 *         if stopping is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
  __pyx_t_1 = (__pyx_v_stopping != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "SLEPc/PEP.pyx":984
 *         """
 *         if stopping is not None:
 *             if args is None: args = ()             # <<<<<<<<<<<<<<
 *             if kargs is None: kargs = {}
 *             self.set_attr('__stopping__', (stopping, args, kargs))
 */
    __pyx_t_2 = (__pyx_v_args == Py_None);
    __pyx_t_1 = (__pyx_t_2 != 0);
    if (__pyx_t_1) {
      __Pyx_INCREF(__pyx_empty_tuple);
      __Pyx_DECREF_SET(__pyx_v_args, __pyx_empty_tuple);
    }

    /* "SLEPc/PEP.pyx":985
 *         if stopping is not None:
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}             # <<<<<<<<<<<<<<
 *             self.set_attr('__stopping__', (stopping, args, kargs))
 *             CHKERR( PEPSetStoppingTestFunction(self.pep, PEP_Stopping, NULL, NULL) )
 */
    __pyx_t_1 = (__pyx_v_kargs == Py_None);
    __pyx_t_2 = (__pyx_t_1 != 0);
    if (__pyx_t_2) {
      __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 985, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF_SET(__pyx_v_kargs, __pyx_t_3);
      __pyx_t_3 = 0;
    }

    /* "SLEPc/PEP.pyx":986
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 *             self.set_attr('__stopping__', (stopping, args, kargs))             # <<<<<<<<<<<<<<
 *             CHKERR( PEPSetStoppingTestFunction(self.pep, PEP_Stopping, NULL, NULL) )
 *         else:
 */
    __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_stopping);
    __Pyx_GIVEREF(__pyx_v_stopping);
    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_stopping);
    __Pyx_INCREF(__pyx_v_args);
    __Pyx_GIVEREF(__pyx_v_args);
    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_args);
    __Pyx_INCREF(__pyx_v_kargs);
    __Pyx_GIVEREF(__pyx_v_kargs);
    PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_kargs);
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_PEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__stopping__"), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 986, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "SLEPc/PEP.pyx":987
 *             if kargs is None: kargs = {}
 *             self.set_attr('__stopping__', (stopping, args, kargs))
 *             CHKERR( PEPSetStoppingTestFunction(self.pep, PEP_Stopping, NULL, NULL) )             # <<<<<<<<<<<<<<
 *         else:
 *             self.set_attr('__stopping__', None)
 */
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetStoppingTestFunction(__pyx_v_self->pep, __pyx_f_8slepc4py_5SLEPc_PEP_Stopping, NULL, NULL)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(19, 987, __pyx_L1_error)

    /* "SLEPc/PEP.pyx":983
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 *         """
 *         if stopping is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
    goto __pyx_L3;
  }

  /* "SLEPc/PEP.pyx":989
 *             CHKERR( PEPSetStoppingTestFunction(self.pep, PEP_Stopping, NULL, NULL) )
 *         else:
 *             self.set_attr('__stopping__', None)             # <<<<<<<<<<<<<<
 *             CHKERR( PEPSetStoppingTestFunction(self.pep, PEPStoppingBasic, NULL, NULL) )
 * 
 */
  /*else*/ {
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_PEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__stopping__"), Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 989, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "SLEPc/PEP.pyx":990
 *         else:
 *             self.set_attr('__stopping__', None)
 *             CHKERR( PEPSetStoppingTestFunction(self.pep, PEPStoppingBasic, NULL, NULL) )             # <<<<<<<<<<<<<<
 * 
 *     def getStoppingTest(self):
 */
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetStoppingTestFunction(__pyx_v_self->pep, PEPStoppingBasic, NULL, NULL)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(19, 990, __pyx_L1_error)
  }
  __pyx_L3:;

  /* "SLEPc/PEP.pyx":979
 *     #
 * 
 *     def setStoppingTest(self, stopping, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setStoppingTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":992
 *             CHKERR( PEPSetStoppingTestFunction(self.pep, PEPStoppingBasic, NULL, NULL) )
 * 
 *     def getStoppingTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the stopping function.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_97getStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_96getStoppingTest[] = "PEP.getStoppingTest(self)\n\n        Gets the stopping function.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_97getStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getStoppingTest (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getStoppingTest", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getStoppingTest", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_96getStoppingTest(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_96getStoppingTest(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getStoppingTest", 0);

  /* "SLEPc/PEP.pyx":996
 *         Gets the stopping function.
 *         """
 *         return self.get_attr('__stopping__')             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_PEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__stopping__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 996, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":992
 *             CHKERR( PEPSetStoppingTestFunction(self.pep, PEPStoppingBasic, NULL, NULL) )
 * 
 *     def getStoppingTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the stopping function.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getStoppingTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1000
 *     #
 * 
 *     def setMonitor(self, monitor, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Appends a monitor function to the list of monitors.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_99setMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_98setMonitor[] = "PEP.setMonitor(self, monitor, args=None, kargs=None)\n\n        Appends a monitor function to the list of monitors.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_99setMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_monitor = 0;
  PyObject *__pyx_v_args = 0;
  PyObject *__pyx_v_kargs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setMonitor (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_monitor,&__pyx_n_s_args,&__pyx_n_s_kargs,0};
    PyObject* values[3] = {0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_monitor)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kargs);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setMonitor") < 0)) __PYX_ERR(19, 1000, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_monitor = values[0];
    __pyx_v_args = values[1];
    __pyx_v_kargs = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setMonitor", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1000, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_98setMonitor(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_monitor, __pyx_v_args, __pyx_v_kargs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_98setMonitor(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_monitor, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs) {
  PyObject *__pyx_v_monitorlist = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setMonitor", 0);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);

  /* "SLEPc/PEP.pyx":1004
 *         Appends a monitor function to the list of monitors.
 *         """
 *         if monitor is None: return             # <<<<<<<<<<<<<<
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:
 */
  __pyx_t_1 = (__pyx_v_monitor == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;
  }

  /* "SLEPc/PEP.pyx":1005
 *         """
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 *         if monitorlist is None:
 *             monitorlist = []
 */
  __pyx_t_3 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_PEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__")); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 1005, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_monitorlist = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/PEP.pyx":1006
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:             # <<<<<<<<<<<<<<
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 */
  __pyx_t_2 = (__pyx_v_monitorlist == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {

    /* "SLEPc/PEP.pyx":1007
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:
 *             monitorlist = []             # <<<<<<<<<<<<<<
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( PEPMonitorSet(self.pep, PEP_Monitor, NULL, NULL) )
 */
    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 1007, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_monitorlist, __pyx_t_3);
    __pyx_t_3 = 0;

    /* "SLEPc/PEP.pyx":1008
 *         if monitorlist is None:
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)             # <<<<<<<<<<<<<<
 *             CHKERR( PEPMonitorSet(self.pep, PEP_Monitor, NULL, NULL) )
 *         if args is None: args = ()
 */
    __pyx_t_3 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_PEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__"), __pyx_v_monitorlist); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 1008, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

    /* "SLEPc/PEP.pyx":1009
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( PEPMonitorSet(self.pep, PEP_Monitor, NULL, NULL) )             # <<<<<<<<<<<<<<
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPMonitorSet(__pyx_v_self->pep, __pyx_f_8slepc4py_5SLEPc_PEP_Monitor, NULL, NULL)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(19, 1009, __pyx_L1_error)

    /* "SLEPc/PEP.pyx":1006
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:             # <<<<<<<<<<<<<<
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 */
  }

  /* "SLEPc/PEP.pyx":1010
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( PEPMonitorSet(self.pep, PEP_Monitor, NULL, NULL) )
 *         if args is None: args = ()             # <<<<<<<<<<<<<<
 *         if kargs is None: kargs = {}
 *         monitorlist.append((monitor, args, kargs))
 */
  __pyx_t_1 = (__pyx_v_args == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __Pyx_INCREF(__pyx_empty_tuple);
    __Pyx_DECREF_SET(__pyx_v_args, __pyx_empty_tuple);
  }

  /* "SLEPc/PEP.pyx":1011
 *             CHKERR( PEPMonitorSet(self.pep, PEP_Monitor, NULL, NULL) )
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}             # <<<<<<<<<<<<<<
 *         monitorlist.append((monitor, args, kargs))
 * 
 */
  __pyx_t_2 = (__pyx_v_kargs == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 1011, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_kargs, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/PEP.pyx":1012
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}
 *         monitorlist.append((monitor, args, kargs))             # <<<<<<<<<<<<<<
 * 
 *     def getMonitor(self):
 */
  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 1012, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_monitor);
  __Pyx_GIVEREF(__pyx_v_monitor);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_monitor);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_GIVEREF(__pyx_v_args);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);
  __Pyx_GIVEREF(__pyx_v_kargs);
  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_kargs);
  __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_monitorlist, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(19, 1012, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/PEP.pyx":1000
 *     #
 * 
 *     def setMonitor(self, monitor, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Appends a monitor function to the list of monitors.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_monitorlist);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1014
 *         monitorlist.append((monitor, args, kargs))
 * 
 *     def getMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the list of monitor functions.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_101getMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_100getMonitor[] = "PEP.getMonitor(self)\n\n        Gets the list of monitor functions.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_101getMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getMonitor (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getMonitor", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getMonitor", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_100getMonitor(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_100getMonitor(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getMonitor", 0);

  /* "SLEPc/PEP.pyx":1018
 *         Gets the list of monitor functions.
 *         """
 *         return self.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 * 
 *     def cancelMonitor(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_PEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1018, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1014
 *         monitorlist.append((monitor, args, kargs))
 * 
 *     def getMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the list of monitor functions.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1020
 *         return self.get_attr('__monitor__')
 * 
 *     def cancelMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Clears all monitors for a `PEP` object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_103cancelMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_102cancelMonitor[] = "PEP.cancelMonitor(self)\n\n        Clears all monitors for a `PEP` object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_103cancelMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("cancelMonitor (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("cancelMonitor", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "cancelMonitor", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_102cancelMonitor(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_102cancelMonitor(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("cancelMonitor", 0);

  /* "SLEPc/PEP.pyx":1024
 *         Clears all monitors for a `PEP` object.
 *         """
 *         CHKERR( PEPMonitorCancel(self.pep) )             # <<<<<<<<<<<<<<
 *         self.set_attr('__monitor__', None)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPMonitorCancel(__pyx_v_self->pep)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1024, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1025
 *         """
 *         CHKERR( PEPMonitorCancel(self.pep) )
 *         self.set_attr('__monitor__', None)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_2 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_PEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__"), Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1025, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":1020
 *         return self.get_attr('__monitor__')
 * 
 *     def cancelMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Clears all monitors for a `PEP` object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.cancelMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1029
 *     #
 * 
 *     def setUp(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets up all the internal data structures necessary for the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_105setUp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_104setUp[] = "PEP.setUp(self)\n\n        Sets up all the internal data structures necessary for the\n        execution of the eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_105setUp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setUp (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setUp", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setUp", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_104setUp(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_104setUp(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setUp", 0);

  /* "SLEPc/PEP.pyx":1034
 *         execution of the eigensolver.
 *         """
 *         CHKERR( PEPSetUp(self.pep) )             # <<<<<<<<<<<<<<
 * 
 *     def solve(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSetUp(__pyx_v_self->pep)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1034, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1029
 *     #
 * 
 *     def setUp(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets up all the internal data structures necessary for the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setUp", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1036
 *         CHKERR( PEPSetUp(self.pep) )
 * 
 *     def solve(self):             # <<<<<<<<<<<<<<
 *         """
 *         Solves the eigensystem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_107solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_106solve[] = "PEP.solve(self)\n\n        Solves the eigensystem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_107solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("solve (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("solve", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "solve", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_106solve(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_106solve(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("solve", 0);

  /* "SLEPc/PEP.pyx":1040
 *         Solves the eigensystem.
 *         """
 *         CHKERR( PEPSolve(self.pep) )             # <<<<<<<<<<<<<<
 * 
 *     def getIterationNumber(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSolve(__pyx_v_self->pep)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1040, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1036
 *         CHKERR( PEPSetUp(self.pep) )
 * 
 *     def solve(self):             # <<<<<<<<<<<<<<
 *         """
 *         Solves the eigensystem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.solve", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1042
 *         CHKERR( PEPSolve(self.pep) )
 * 
 *     def getIterationNumber(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the current iteration number. If the call to `solve()` is
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_109getIterationNumber(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_108getIterationNumber[] = "PEP.getIterationNumber(self)\n\n        Gets the current iteration number. If the call to `solve()` is\n        complete, then it returns the number of iterations carried out\n        by the solution method.\n\n        Returns\n        -------\n        its: int\n             Iteration number.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_109getIterationNumber(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getIterationNumber (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getIterationNumber", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getIterationNumber", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_108getIterationNumber(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_108getIterationNumber(struct PySlepcPEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getIterationNumber", 0);

  /* "SLEPc/PEP.pyx":1053
 *              Iteration number.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetIterationNumber(self.pep, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/PEP.pyx":1054
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( PEPGetIterationNumber(self.pep, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetIterationNumber(__pyx_v_self->pep, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1054, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1055
 *         cdef PetscInt ival = 0
 *         CHKERR( PEPGetIterationNumber(self.pep, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def getConvergedReason(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1055, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1042
 *         CHKERR( PEPSolve(self.pep) )
 * 
 *     def getIterationNumber(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the current iteration number. If the call to `solve()` is
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getIterationNumber", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1057
 *         return toInt(ival)
 * 
 *     def getConvergedReason(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the reason why the `solve()` iteration was stopped.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_111getConvergedReason(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_110getConvergedReason[] = "PEP.getConvergedReason(self)\n\n        Gets the reason why the `solve()` iteration was stopped.\n\n        Returns\n        -------\n        reason: `PEP.ConvergedReason` enumerate\n            Negative value indicates diverged, positive value\n            converged.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_111getConvergedReason(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getConvergedReason (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getConvergedReason", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConvergedReason", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_110getConvergedReason(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_110getConvergedReason(struct PySlepcPEPObject *__pyx_v_self) {
  PEPConvergedReason __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getConvergedReason", 0);

  /* "SLEPc/PEP.pyx":1067
 *             converged.
 *         """
 *         cdef SlepcPEPConvergedReason val = PEP_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetConvergedReason(self.pep, &val) )
 *         return val
 */
  __pyx_v_val = PEP_CONVERGED_ITERATING;

  /* "SLEPc/PEP.pyx":1068
 *         """
 *         cdef SlepcPEPConvergedReason val = PEP_CONVERGED_ITERATING
 *         CHKERR( PEPGetConvergedReason(self.pep, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetConvergedReason(__pyx_v_self->pep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1068, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1069
 *         cdef SlepcPEPConvergedReason val = PEP_CONVERGED_ITERATING
 *         CHKERR( PEPGetConvergedReason(self.pep, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def getConverged(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_PEPConvergedReason(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1069, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1057
 *         return toInt(ival)
 * 
 *     def getConvergedReason(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the reason why the `solve()` iteration was stopped.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getConvergedReason", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1071
 *         return val
 * 
 *     def getConverged(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of converged eigenpairs.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_113getConverged(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_112getConverged[] = "PEP.getConverged(self)\n\n        Gets the number of converged eigenpairs.\n\n        Returns\n        -------\n        nconv: int\n            Number of converged eigenpairs.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_113getConverged(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getConverged (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getConverged", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConverged", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_112getConverged(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_112getConverged(struct PySlepcPEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getConverged", 0);

  /* "SLEPc/PEP.pyx":1080
 *             Number of converged eigenpairs.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetConverged(self.pep, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/PEP.pyx":1081
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( PEPGetConverged(self.pep, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetConverged(__pyx_v_self->pep, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1081, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1082
 *         cdef PetscInt ival = 0
 *         CHKERR( PEPGetConverged(self.pep, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def getEigenpair(self, int i, Vec Vr=None, Vec Vi=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1082, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1071
 *         return val
 * 
 *     def getConverged(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of converged eigenpairs.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getConverged", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1084
 *         return toInt(ival)
 * 
 *     def getEigenpair(self, int i, Vec Vr=None, Vec Vi=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th solution of the eigenproblem as computed by
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_115getEigenpair(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_114getEigenpair[] = "PEP.getEigenpair(self, int i, Vec Vr=None, Vec Vi=None)\n\n        Gets the i-th solution of the eigenproblem as computed by\n        `solve()`.  The solution consists of both the eigenvalue and\n        the eigenvector.\n\n        Parameters\n        ----------\n        i: int\n            Index of the solution to be obtained.\n        Vr: Vec, optional\n            Placeholder for the returned eigenvector (real part).\n        Vi: Vec, optional\n            Placeholder for the returned eigenvector (imaginary part).\n\n        Returns\n        -------\n        e: scalar (possibly complex)\n            The computed eigenvalue.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_115getEigenpair(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  struct PyPetscVecObject *__pyx_v_Vr = 0;
  struct PyPetscVecObject *__pyx_v_Vi = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getEigenpair (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,&__pyx_n_s_Vr,&__pyx_n_s_Vi,0};
    PyObject* values[3] = {0,0,0};
    values[1] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    values[2] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Vr);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Vi);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getEigenpair") < 0)) __PYX_ERR(19, 1084, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(19, 1084, __pyx_L3_error)
    __pyx_v_Vr = ((struct PyPetscVecObject *)values[1]);
    __pyx_v_Vi = ((struct PyPetscVecObject *)values[2]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getEigenpair", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1084, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getEigenpair", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Vr), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "Vr", 0))) __PYX_ERR(19, 1084, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Vi), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "Vi", 0))) __PYX_ERR(19, 1084, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_114getEigenpair(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_i, __pyx_v_Vr, __pyx_v_Vi);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_114getEigenpair(struct PySlepcPEPObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_Vr, struct PyPetscVecObject *__pyx_v_Vi) {
  PetscScalar __pyx_v_sval1;
  PetscScalar __pyx_v_sval2;
  Vec __pyx_v_vecr;
  Vec __pyx_v_veci;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Vec __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getEigenpair", 0);

  /* "SLEPc/PEP.pyx":1104
 *             The computed eigenvalue.
 *         """
 *         cdef PetscScalar sval1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar sval2 = 0
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL
 */
  __pyx_v_sval1 = 0.0;

  /* "SLEPc/PEP.pyx":1105
 *         """
 *         cdef PetscScalar sval1 = 0
 *         cdef PetscScalar sval2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL
 */
  __pyx_v_sval2 = 0.0;

  /* "SLEPc/PEP.pyx":1106
 *         cdef PetscScalar sval1 = 0
 *         cdef PetscScalar sval2 = 0
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL             # <<<<<<<<<<<<<<
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL
 *         CHKERR( PEPGetEigenpair(self.pep, i, &sval1, &sval2, vecr, veci) )
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_Vr) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_Vr->vec;
  } else {
    __pyx_t_1 = ((Vec)NULL);
  }
  __pyx_v_vecr = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1107
 *         cdef PetscScalar sval2 = 0
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetEigenpair(self.pep, i, &sval1, &sval2, vecr, veci) )
 *         return toComplex(sval1, sval2)
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_Vi) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_Vi->vec;
  } else {
    __pyx_t_1 = ((Vec)NULL);
  }
  __pyx_v_veci = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1108
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL
 *         CHKERR( PEPGetEigenpair(self.pep, i, &sval1, &sval2, vecr, veci) )             # <<<<<<<<<<<<<<
 *         return toComplex(sval1, sval2)
 * 
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetEigenpair(__pyx_v_self->pep, __pyx_v_i, (&__pyx_v_sval1), (&__pyx_v_sval2), __pyx_v_vecr, __pyx_v_veci)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(19, 1108, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1109
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL
 *         CHKERR( PEPGetEigenpair(self.pep, i, &sval1, &sval2, vecr, veci) )
 *         return toComplex(sval1, sval2)             # <<<<<<<<<<<<<<
 * 
 *     def getErrorEstimate(self, int i):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toComplex(__pyx_v_sval1, __pyx_v_sval2); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 1109, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1084
 *         return toInt(ival)
 * 
 *     def getEigenpair(self, int i, Vec Vr=None, Vec Vi=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th solution of the eigenproblem as computed by
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getEigenpair", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1111
 *         return toComplex(sval1, sval2)
 * 
 *     def getErrorEstimate(self, int i):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the error estimate associated to the i-th computed
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_117getErrorEstimate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_116getErrorEstimate[] = "PEP.getErrorEstimate(self, int i)\n\n        Returns the error estimate associated to the i-th computed\n        eigenpair.\n\n        Parameters\n        ----------\n        i: int\n            Index of the solution to be considered.\n\n        Returns\n        -------\n        error: real\n            Error estimate.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_117getErrorEstimate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getErrorEstimate (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getErrorEstimate") < 0)) __PYX_ERR(19, 1111, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(19, 1111, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getErrorEstimate", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1111, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getErrorEstimate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_116getErrorEstimate(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_i);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_116getErrorEstimate(struct PySlepcPEPObject *__pyx_v_self, int __pyx_v_i) {
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getErrorEstimate", 0);

  /* "SLEPc/PEP.pyx":1126
 *             Error estimate.
 *         """
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPGetErrorEstimate(self.pep, i, &rval) )
 *         return toReal(rval)
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/PEP.pyx":1127
 *         """
 *         cdef PetscReal rval = 0
 *         CHKERR( PEPGetErrorEstimate(self.pep, i, &rval) )             # <<<<<<<<<<<<<<
 *         return toReal(rval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPGetErrorEstimate(__pyx_v_self->pep, __pyx_v_i, (&__pyx_v_rval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1127, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1128
 *         cdef PetscReal rval = 0
 *         CHKERR( PEPGetErrorEstimate(self.pep, i, &rval) )
 *         return toReal(rval)             # <<<<<<<<<<<<<<
 * 
 *     def computeError(self, int i, etype=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1128, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1111
 *         return toComplex(sval1, sval2)
 * 
 *     def getErrorEstimate(self, int i):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the error estimate associated to the i-th computed
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getErrorEstimate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1130
 *         return toReal(rval)
 * 
 *     def computeError(self, int i, etype=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the error (based on the residual norm) associated with the i-th
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_119computeError(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_118computeError[] = "PEP.computeError(self, int i, etype=None)\n\n        Computes the error (based on the residual norm) associated with the i-th\n        computed eigenpair.\n\n        Parameters\n        ----------\n        i: int\n           Index of the solution to be considered.\n        etype: `PEP.ErrorType` enumerate\n           The error type to compute.\n\n        Returns\n        -------\n        error: real\n           The error bound, computed in various ways from the\n           residual norm ``||P(l)x||_2`` where ``l`` is the\n           eigenvalue and ``x`` is the eigenvector.\n\n        Notes\n        -----\n        The index ``i`` should be a value between ``0`` and\n        ``nconv-1`` (see `getConverged()`).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_119computeError(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  PyObject *__pyx_v_etype = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("computeError (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,&__pyx_n_s_etype,0};
    PyObject* values[2] = {0,0};
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_etype);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "computeError") < 0)) __PYX_ERR(19, 1130, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(19, 1130, __pyx_L3_error)
    __pyx_v_etype = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("computeError", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1130, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.computeError", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_118computeError(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_i, __pyx_v_etype);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_118computeError(struct PySlepcPEPObject *__pyx_v_self, int __pyx_v_i, PyObject *__pyx_v_etype) {
  PEPErrorType __pyx_v_et;
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PEPErrorType __pyx_t_3;
  int __pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("computeError", 0);

  /* "SLEPc/PEP.pyx":1154
 *         ``nconv-1`` (see `getConverged()`).
 *         """
 *         cdef SlepcPEPErrorType et = PEP_ERROR_BACKWARD             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval = 0
 *         if etype is not None: et = etype
 */
  __pyx_v_et = PEP_ERROR_BACKWARD;

  /* "SLEPc/PEP.pyx":1155
 *         """
 *         cdef SlepcPEPErrorType et = PEP_ERROR_BACKWARD
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         if etype is not None: et = etype
 *         CHKERR( PEPComputeError(self.pep, i, et, &rval) )
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/PEP.pyx":1156
 *         cdef SlepcPEPErrorType et = PEP_ERROR_BACKWARD
 *         cdef PetscReal rval = 0
 *         if etype is not None: et = etype             # <<<<<<<<<<<<<<
 *         CHKERR( PEPComputeError(self.pep, i, et, &rval) )
 *         return toReal(rval)
 */
  __pyx_t_1 = (__pyx_v_etype != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = ((PEPErrorType)__Pyx_PyInt_As_PEPErrorType(__pyx_v_etype)); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 1156, __pyx_L1_error)
    __pyx_v_et = __pyx_t_3;
  }

  /* "SLEPc/PEP.pyx":1157
 *         cdef PetscReal rval = 0
 *         if etype is not None: et = etype
 *         CHKERR( PEPComputeError(self.pep, i, et, &rval) )             # <<<<<<<<<<<<<<
 *         return toReal(rval)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPComputeError(__pyx_v_self->pep, __pyx_v_i, __pyx_v_et, (&__pyx_v_rval))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(19, 1157, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1158
 *         if etype is not None: et = etype
 *         CHKERR( PEPComputeError(self.pep, i, et, &rval) )
 *         return toReal(rval)             # <<<<<<<<<<<<<<
 * 
 *     def errorView(self, etype=None, Viewer viewer=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_5)) __PYX_ERR(19, 1158, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1130
 *         return toReal(rval)
 * 
 *     def computeError(self, int i, etype=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the error (based on the residual norm) associated with the i-th
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.computeError", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1160
 *         return toReal(rval)
 * 
 *     def errorView(self, etype=None, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the errors associated with the computed solution
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_121errorView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_120errorView[] = "PEP.errorView(self, etype=None, Viewer viewer=None)\n\n        Displays the errors associated with the computed solution\n        (as well as the eigenvalues).\n\n        Parameters\n        ----------\n        etype: `PEP.ErrorType` enumerate, optional\n           The error type to compute.\n        viewer: Viewer, optional.\n                Visualization context; if not provided, the standard\n                output is used.\n\n        Notes\n        -----\n        By default, this function checks the error of all eigenpairs and prints\n        the eigenvalues if all of them are below the requested tolerance.\n        If the viewer has format ``ASCII_INFO_DETAIL`` then a table with\n        eigenvalues and corresponding errors is printed.\n\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_121errorView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_etype = 0;
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("errorView (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_etype,&__pyx_n_s_viewer,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_etype);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "errorView") < 0)) __PYX_ERR(19, 1160, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_etype = values[0];
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("errorView", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1160, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.errorView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(19, 1160, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_120errorView(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_etype, __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_120errorView(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_etype, struct PyPetscViewerObject *__pyx_v_viewer) {
  PEPErrorType __pyx_v_et;
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PEPErrorType __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("errorView", 0);

  /* "SLEPc/PEP.pyx":1181
 * 
 *         """
 *         cdef SlepcPEPErrorType et = PEP_ERROR_RELATIVE             # <<<<<<<<<<<<<<
 *         if etype is not None: et = etype
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 */
  __pyx_v_et = PEP_ERROR_RELATIVE;

  /* "SLEPc/PEP.pyx":1182
 *         """
 *         cdef SlepcPEPErrorType et = PEP_ERROR_RELATIVE
 *         if etype is not None: et = etype             # <<<<<<<<<<<<<<
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( PEPErrorView(self.pep, et, vwr) )
 */
  __pyx_t_1 = (__pyx_v_etype != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = ((PEPErrorType)__Pyx_PyInt_As_PEPErrorType(__pyx_v_etype)); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 1182, __pyx_L1_error)
    __pyx_v_et = __pyx_t_3;
  }

  /* "SLEPc/PEP.pyx":1183
 *         cdef SlepcPEPErrorType et = PEP_ERROR_RELATIVE
 *         if etype is not None: et = etype
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPErrorView(self.pep, et, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/PEP.pyx":1184
 *         if etype is not None: et = etype
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( PEPErrorView(self.pep, et, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def valuesView(self, Viewer viewer=None):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPErrorView(__pyx_v_self->pep, __pyx_v_et, __pyx_v_vwr)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(19, 1184, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1160
 *         return toReal(rval)
 * 
 *     def errorView(self, etype=None, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the errors associated with the computed solution
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.errorView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1186
 *         CHKERR( PEPErrorView(self.pep, et, vwr) )
 * 
 *     def valuesView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the computed eigenvalues in a viewer.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_123valuesView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_122valuesView[] = "PEP.valuesView(self, Viewer viewer=None)\n\n        Displays the computed eigenvalues in a viewer.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional.\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_123valuesView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("valuesView (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "valuesView") < 0)) __PYX_ERR(19, 1186, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("valuesView", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1186, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.valuesView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(19, 1186, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_122valuesView(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_122valuesView(struct PySlepcPEPObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("valuesView", 0);

  /* "SLEPc/PEP.pyx":1196
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPValuesView(self.pep, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/PEP.pyx":1197
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( PEPValuesView(self.pep, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def vectorsView(self, Viewer viewer=None):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPValuesView(__pyx_v_self->pep, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1197, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1186
 *         CHKERR( PEPErrorView(self.pep, et, vwr) )
 * 
 *     def valuesView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the computed eigenvalues in a viewer.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.valuesView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1199
 *         CHKERR( PEPValuesView(self.pep, vwr) )
 * 
 *     def vectorsView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Outputs computed eigenvectors to a viewer.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_125vectorsView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_124vectorsView[] = "PEP.vectorsView(self, Viewer viewer=None)\n\n        Outputs computed eigenvectors to a viewer.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional.\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_125vectorsView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("vectorsView (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "vectorsView") < 0)) __PYX_ERR(19, 1199, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("vectorsView", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1199, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.vectorsView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(19, 1199, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_124vectorsView(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_124vectorsView(struct PySlepcPEPObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("vectorsView", 0);

  /* "SLEPc/PEP.pyx":1209
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPVectorsView(self.pep, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/PEP.pyx":1210
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( PEPVectorsView(self.pep, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPVectorsView(__pyx_v_self->pep, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1210, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1199
 *         CHKERR( PEPValuesView(self.pep, vwr) )
 * 
 *     def vectorsView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Outputs computed eigenvectors to a viewer.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.vectorsView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1214
 *     #
 * 
 *     def setLinearEPS(self, EPS eps):             # <<<<<<<<<<<<<<
 *         """
 *         Associate an eigensolver object to the polynomial eigenvalue solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_127setLinearEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_126setLinearEPS[] = "PEP.setLinearEPS(self, EPS eps)\n\n        Associate an eigensolver object to the polynomial eigenvalue solver.\n\n        Parameters\n        ----------\n        eps: `EPS`\n            The linear eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_127setLinearEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcEPSObject *__pyx_v_eps = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setLinearEPS (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_eps,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_eps)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setLinearEPS") < 0)) __PYX_ERR(19, 1214, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_eps = ((struct PySlepcEPSObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setLinearEPS", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1214, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setLinearEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_eps), __pyx_ptype_8slepc4py_5SLEPc_EPS, 0, "eps", 0))) __PYX_ERR(19, 1214, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_126setLinearEPS(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_eps);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_126setLinearEPS(struct PySlepcPEPObject *__pyx_v_self, struct PySlepcEPSObject *__pyx_v_eps) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setLinearEPS", 0);

  /* "SLEPc/PEP.pyx":1223
 *             The linear eigensolver.
 *         """
 *         CHKERR( PEPLinearSetEPS(self.pep, eps.eps) )             # <<<<<<<<<<<<<<
 * 
 *     def getLinearEPS(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPLinearSetEPS(__pyx_v_self->pep, __pyx_v_eps->eps)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1223, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1214
 *     #
 * 
 *     def setLinearEPS(self, EPS eps):             # <<<<<<<<<<<<<<
 *         """
 *         Associate an eigensolver object to the polynomial eigenvalue solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setLinearEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1225
 *         CHKERR( PEPLinearSetEPS(self.pep, eps.eps) )
 * 
 *     def getLinearEPS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the eigensolver object associated to the polynomial
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_129getLinearEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_128getLinearEPS[] = "PEP.getLinearEPS(self)\n\n        Retrieve the eigensolver object associated to the polynomial\n        eigenvalue solver.\n\n        Returns\n        -------\n        eps: `EPS`\n            The linear eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_129getLinearEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getLinearEPS (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getLinearEPS", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLinearEPS", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_128getLinearEPS(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_128getLinearEPS(struct PySlepcPEPObject *__pyx_v_self) {
  struct PySlepcEPSObject *__pyx_v_eps = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getLinearEPS", 0);

  /* "SLEPc/PEP.pyx":1235
 *             The linear eigensolver.
 *         """
 *         cdef EPS eps = EPS()             # <<<<<<<<<<<<<<
 *         CHKERR( PEPLinearGetEPS(self.pep, &eps.eps) )
 *         PetscINCREF(eps.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS)); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1235, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_eps = ((struct PySlepcEPSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":1236
 *         """
 *         cdef EPS eps = EPS()
 *         CHKERR( PEPLinearGetEPS(self.pep, &eps.eps) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(eps.obj)
 *         return eps
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPLinearGetEPS(__pyx_v_self->pep, (&__pyx_v_eps->eps))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1236, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1237
 *         cdef EPS eps = EPS()
 *         CHKERR( PEPLinearGetEPS(self.pep, &eps.eps) )
 *         PetscINCREF(eps.obj)             # <<<<<<<<<<<<<<
 *         return eps
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_eps->__pyx_base.obj));

  /* "SLEPc/PEP.pyx":1238
 *         CHKERR( PEPLinearGetEPS(self.pep, &eps.eps) )
 *         PetscINCREF(eps.obj)
 *         return eps             # <<<<<<<<<<<<<<
 * 
 *     def setLinearLinearization(self, alpha=1.0, beta=0.0):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_eps));
  __pyx_r = ((PyObject *)__pyx_v_eps);
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1225
 *         CHKERR( PEPLinearSetEPS(self.pep, eps.eps) )
 * 
 *     def getLinearEPS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the eigensolver object associated to the polynomial
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getLinearEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_eps);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1240
 *         return eps
 * 
 *     def setLinearLinearization(self, alpha=1.0, beta=0.0):             # <<<<<<<<<<<<<<
 *         """
 *         Set the coefficients that define the linearization of a quadratic eigenproblem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_131setLinearLinearization(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_130setLinearLinearization[] = "PEP.setLinearLinearization(self, alpha=1.0, beta=0.0)\n\n        Set the coefficients that define the linearization of a quadratic eigenproblem.\n\n        Parameters\n        ----------\n        alpha: float\n            First parameter of the linearization.\n        beta: float\n            Second parameter of the linearization.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_131setLinearLinearization(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_alpha = 0;
  PyObject *__pyx_v_beta = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setLinearLinearization (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alpha,&__pyx_n_s_beta,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)__pyx_float_1_0);
    values[1] = ((PyObject *)__pyx_float_0_0);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_beta);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setLinearLinearization") < 0)) __PYX_ERR(19, 1240, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_alpha = values[0];
    __pyx_v_beta = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setLinearLinearization", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1240, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setLinearLinearization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_130setLinearLinearization(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_alpha, __pyx_v_beta);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_130setLinearLinearization(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_alpha, PyObject *__pyx_v_beta) {
  PetscReal __pyx_v_a;
  PetscReal __pyx_v_b;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setLinearLinearization", 0);

  /* "SLEPc/PEP.pyx":1251
 *             Second parameter of the linearization.
 *         """
 *         cdef PetscReal a = asReal(alpha)             # <<<<<<<<<<<<<<
 *         cdef PetscReal b = asReal(beta)
 *         CHKERR( PEPLinearSetLinearization(self.pep, a, b) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_alpha); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 1251, __pyx_L1_error)
  __pyx_v_a = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1252
 *         """
 *         cdef PetscReal a = asReal(alpha)
 *         cdef PetscReal b = asReal(beta)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPLinearSetLinearization(self.pep, a, b) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_beta); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 1252, __pyx_L1_error)
  __pyx_v_b = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1253
 *         cdef PetscReal a = asReal(alpha)
 *         cdef PetscReal b = asReal(beta)
 *         CHKERR( PEPLinearSetLinearization(self.pep, a, b) )             # <<<<<<<<<<<<<<
 * 
 *     def getLinearLinearization(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPLinearSetLinearization(__pyx_v_self->pep, __pyx_v_a, __pyx_v_b)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1253, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1240
 *         return eps
 * 
 *     def setLinearLinearization(self, alpha=1.0, beta=0.0):             # <<<<<<<<<<<<<<
 *         """
 *         Set the coefficients that define the linearization of a quadratic eigenproblem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setLinearLinearization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1255
 *         CHKERR( PEPLinearSetLinearization(self.pep, a, b) )
 * 
 *     def getLinearLinearization(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the coefficients that define the linearization of a quadratic eigenproblem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_133getLinearLinearization(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_132getLinearLinearization[] = "PEP.getLinearLinearization(self)\n\n        Returns the coefficients that define the linearization of a quadratic eigenproblem.\n\n        Returns\n        -------\n        alpha: float\n            First parameter of the linearization.\n        beta: float\n            Second parameter of the linearization.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_133getLinearLinearization(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getLinearLinearization (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getLinearLinearization", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLinearLinearization", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_132getLinearLinearization(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_132getLinearLinearization(struct PySlepcPEPObject *__pyx_v_self) {
  PetscReal __pyx_v_a;
  PetscReal __pyx_v_b;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PetscReal __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getLinearLinearization", 0);

  /* "SLEPc/PEP.pyx":1266
 *             Second parameter of the linearization.
 *         """
 *         cdef PetscReal a = 0.0             # <<<<<<<<<<<<<<
 *         cdef PetscReal b = 0.0
 *         CHKERR( PEPLinearGetLinearization(self.pep, &a, &b) )
 */
  __pyx_v_a = 0.0;

  /* "SLEPc/PEP.pyx":1267
 *         """
 *         cdef PetscReal a = 0.0
 *         cdef PetscReal b = 0.0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPLinearGetLinearization(self.pep, &a, &b) )
 *         return (asReal(a), asReal(b))
 */
  __pyx_v_b = 0.0;

  /* "SLEPc/PEP.pyx":1268
 *         cdef PetscReal a = 0.0
 *         cdef PetscReal b = 0.0
 *         CHKERR( PEPLinearGetLinearization(self.pep, &a, &b) )             # <<<<<<<<<<<<<<
 *         return (asReal(a), asReal(b))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPLinearGetLinearization(__pyx_v_self->pep, (&__pyx_v_a), (&__pyx_v_b))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1268, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1269
 *         cdef PetscReal b = 0.0
 *         CHKERR( PEPLinearGetLinearization(self.pep, &a, &b) )
 *         return (asReal(a), asReal(b))             # <<<<<<<<<<<<<<
 * 
 *     def setLinearExplicitMatrix(self, flag):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_a); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1269, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_t_2); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 1269, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1269, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_b); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 1269, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_t_4); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 1269, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 1269, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(19, 1269, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
  __pyx_t_2 = 0;
  __pyx_t_4 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1255
 *         CHKERR( PEPLinearSetLinearization(self.pep, a, b) )
 * 
 *     def getLinearLinearization(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the coefficients that define the linearization of a quadratic eigenproblem.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getLinearLinearization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1271
 *         return (asReal(a), asReal(b))
 * 
 *     def setLinearExplicitMatrix(self, flag):             # <<<<<<<<<<<<<<
 *         """
 *         Indicate if the matrices A and B for the linearization of the problem
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_135setLinearExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_134setLinearExplicitMatrix[] = "PEP.setLinearExplicitMatrix(self, flag)\n\n        Indicate if the matrices A and B for the linearization of the problem\n        must be built explicitly.\n\n        Parameters\n        ----------\n        flag: bool\n            Boolean flag indicating if the matrices are built explicitly.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_135setLinearExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_flag = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setLinearExplicitMatrix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flag,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flag)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setLinearExplicitMatrix") < 0)) __PYX_ERR(19, 1271, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_flag = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setLinearExplicitMatrix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1271, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setLinearExplicitMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_134setLinearExplicitMatrix(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_flag);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_134setLinearExplicitMatrix(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_flag) {
  PetscBool __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setLinearExplicitMatrix", 0);

  /* "SLEPc/PEP.pyx":1281
 *             Boolean flag indicating if the matrices are built explicitly.
 *         """
 *         cdef PetscBool sval = asBool(flag)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPLinearSetExplicitMatrix(self.pep, sval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_flag); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(19, 1281, __pyx_L1_error)
  __pyx_v_sval = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1282
 *         """
 *         cdef PetscBool sval = asBool(flag)
 *         CHKERR( PEPLinearSetExplicitMatrix(self.pep, sval) )             # <<<<<<<<<<<<<<
 * 
 *     def getLinearExplicitMatrix(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPLinearSetExplicitMatrix(__pyx_v_self->pep, __pyx_v_sval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1282, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1271
 *         return (asReal(a), asReal(b))
 * 
 *     def setLinearExplicitMatrix(self, flag):             # <<<<<<<<<<<<<<
 *         """
 *         Indicate if the matrices A and B for the linearization of the problem
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setLinearExplicitMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1284
 *         CHKERR( PEPLinearSetExplicitMatrix(self.pep, sval) )
 * 
 *     def getLinearExplicitMatrix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating if the matrices A and B for the linearization
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_137getLinearExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_136getLinearExplicitMatrix[] = "PEP.getLinearExplicitMatrix(self)\n\n        Returns the flag indicating if the matrices A and B for the linearization\n        are built explicitly.\n\n        Returns\n        -------\n        flag: bool\n            Boolean flag indicating if the matrices are built explicitly.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_137getLinearExplicitMatrix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getLinearExplicitMatrix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getLinearExplicitMatrix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLinearExplicitMatrix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_136getLinearExplicitMatrix(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_136getLinearExplicitMatrix(struct PySlepcPEPObject *__pyx_v_self) {
  PetscBool __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getLinearExplicitMatrix", 0);

  /* "SLEPc/PEP.pyx":1294
 *             Boolean flag indicating if the matrices are built explicitly.
 *         """
 *         cdef PetscBool sval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( PEPLinearGetExplicitMatrix(self.pep, &sval) )
 *         return toBool(sval)
 */
  __pyx_v_sval = PETSC_FALSE;

  /* "SLEPc/PEP.pyx":1295
 *         """
 *         cdef PetscBool sval = PETSC_FALSE
 *         CHKERR( PEPLinearGetExplicitMatrix(self.pep, &sval) )             # <<<<<<<<<<<<<<
 *         return toBool(sval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPLinearGetExplicitMatrix(__pyx_v_self->pep, (&__pyx_v_sval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1295, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1296
 *         cdef PetscBool sval = PETSC_FALSE
 *         CHKERR( PEPLinearGetExplicitMatrix(self.pep, &sval) )
 *         return toBool(sval)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_sval); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1296, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1284
 *         CHKERR( PEPLinearSetExplicitMatrix(self.pep, sval) )
 * 
 *     def getLinearExplicitMatrix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating if the matrices A and B for the linearization
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getLinearExplicitMatrix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1300
 *     #
 * 
 *     def setQArnoldiRestart(self, keep):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the restart parameter for the Q-Arnoldi method, in
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_139setQArnoldiRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_138setQArnoldiRestart[] = "PEP.setQArnoldiRestart(self, keep)\n\n        Sets the restart parameter for the Q-Arnoldi method, in\n        particular the proportion of basis vectors that must be kept\n        after restart.\n\n        Parameters\n        ----------\n        keep: float\n              The number of vectors to be kept at restart.\n\n        Notes\n        -----\n        Allowed values are in the range [0.1,0.9]. The default is 0.5.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_139setQArnoldiRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_keep = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setQArnoldiRestart (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_keep,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_keep)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setQArnoldiRestart") < 0)) __PYX_ERR(19, 1300, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_keep = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setQArnoldiRestart", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1300, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setQArnoldiRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_138setQArnoldiRestart(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_keep);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_138setQArnoldiRestart(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_keep) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setQArnoldiRestart", 0);

  /* "SLEPc/PEP.pyx":1315
 *         Allowed values are in the range [0.1,0.9]. The default is 0.5.
 *         """
 *         cdef PetscReal val = asReal(keep)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPQArnoldiSetRestart(self.pep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_keep); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 1315, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1316
 *         """
 *         cdef PetscReal val = asReal(keep)
 *         CHKERR( PEPQArnoldiSetRestart(self.pep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getQArnoldiRestart(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPQArnoldiSetRestart(__pyx_v_self->pep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1316, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1300
 *     #
 * 
 *     def setQArnoldiRestart(self, keep):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the restart parameter for the Q-Arnoldi method, in
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setQArnoldiRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1318
 *         CHKERR( PEPQArnoldiSetRestart(self.pep, val) )
 * 
 *     def getQArnoldiRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the restart parameter used in the Q-Arnoldi method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_141getQArnoldiRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_140getQArnoldiRestart[] = "PEP.getQArnoldiRestart(self)\n\n        Gets the restart parameter used in the Q-Arnoldi method.\n\n        Returns\n        -------\n        keep: float\n              The number of vectors to be kept at restart.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_141getQArnoldiRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getQArnoldiRestart (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getQArnoldiRestart", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getQArnoldiRestart", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_140getQArnoldiRestart(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_140getQArnoldiRestart(struct PySlepcPEPObject *__pyx_v_self) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getQArnoldiRestart", 0);

  /* "SLEPc/PEP.pyx":1327
 *               The number of vectors to be kept at restart.
 *         """
 *         cdef PetscReal val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPQArnoldiGetRestart(self.pep, &val) )
 *         return toReal(val)
 */
  __pyx_v_val = 0.0;

  /* "SLEPc/PEP.pyx":1328
 *         """
 *         cdef PetscReal val = 0
 *         CHKERR( PEPQArnoldiGetRestart(self.pep, &val) )             # <<<<<<<<<<<<<<
 *         return toReal(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPQArnoldiGetRestart(__pyx_v_self->pep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1328, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1329
 *         cdef PetscReal val = 0
 *         CHKERR( PEPQArnoldiGetRestart(self.pep, &val) )
 *         return toReal(val)             # <<<<<<<<<<<<<<
 * 
 *     def setQArnoldiLocking(self, lock):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1329, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1318
 *         CHKERR( PEPQArnoldiSetRestart(self.pep, val) )
 * 
 *     def getQArnoldiRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the restart parameter used in the Q-Arnoldi method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getQArnoldiRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1331
 *         return toReal(val)
 * 
 *     def setQArnoldiLocking(self, lock):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between locking and non-locking variants of the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_143setQArnoldiLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_142setQArnoldiLocking[] = "PEP.setQArnoldiLocking(self, lock)\n\n        Choose between locking and non-locking variants of the\n        Q-Arnoldi method.\n\n        Parameters\n        ----------\n        lock: bool\n              True if the locking variant must be selected.\n\n        Notes\n        -----\n        The default is to lock converged eigenpairs when the method restarts.\n        This behaviour can be changed so that all directions are kept in the\n        working subspace even if already converged to working accuracy (the\n        non-locking variant).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_143setQArnoldiLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_lock = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setQArnoldiLocking (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lock,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lock)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setQArnoldiLocking") < 0)) __PYX_ERR(19, 1331, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_lock = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setQArnoldiLocking", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1331, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setQArnoldiLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_142setQArnoldiLocking(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_lock);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_142setQArnoldiLocking(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_lock) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setQArnoldiLocking", 0);

  /* "SLEPc/PEP.pyx":1348
 *         non-locking variant).
 *         """
 *         cdef PetscBool val = asBool(lock)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPQArnoldiSetLocking(self.pep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_lock); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(19, 1348, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1349
 *         """
 *         cdef PetscBool val = asBool(lock)
 *         CHKERR( PEPQArnoldiSetLocking(self.pep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getQArnoldiLocking(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPQArnoldiSetLocking(__pyx_v_self->pep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1349, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1331
 *         return toReal(val)
 * 
 *     def setQArnoldiLocking(self, lock):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between locking and non-locking variants of the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setQArnoldiLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1351
 *         CHKERR( PEPQArnoldiSetLocking(self.pep, val) )
 * 
 *     def getQArnoldiLocking(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the locking flag used in the Q-Arnoldi method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_145getQArnoldiLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_144getQArnoldiLocking[] = "PEP.getQArnoldiLocking(self)\n\n        Gets the locking flag used in the Q-Arnoldi method.\n\n        Returns\n        -------\n        lock: bool\n              The locking flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_145getQArnoldiLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getQArnoldiLocking (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getQArnoldiLocking", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getQArnoldiLocking", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_144getQArnoldiLocking(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_144getQArnoldiLocking(struct PySlepcPEPObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getQArnoldiLocking", 0);

  /* "SLEPc/PEP.pyx":1360
 *               The locking flag.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( PEPQArnoldiGetLocking(self.pep, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/PEP.pyx":1361
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( PEPQArnoldiGetLocking(self.pep, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPQArnoldiGetLocking(__pyx_v_self->pep, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1361, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1362
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( PEPQArnoldiGetLocking(self.pep, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1362, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1351
 *         CHKERR( PEPQArnoldiSetLocking(self.pep, val) )
 * 
 *     def getQArnoldiLocking(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the locking flag used in the Q-Arnoldi method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getQArnoldiLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1366
 *     #
 * 
 *     def setTOARRestart(self, keep):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the restart parameter for the TOAR method, in
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_147setTOARRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_146setTOARRestart[] = "PEP.setTOARRestart(self, keep)\n\n        Sets the restart parameter for the TOAR method, in\n        particular the proportion of basis vectors that must be kept\n        after restart.\n\n        Parameters\n        ----------\n        keep: float\n              The number of vectors to be kept at restart.\n\n        Notes\n        -----\n        Allowed values are in the range [0.1,0.9]. The default is 0.5.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_147setTOARRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_keep = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTOARRestart (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_keep,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_keep)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTOARRestart") < 0)) __PYX_ERR(19, 1366, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_keep = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTOARRestart", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1366, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setTOARRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_146setTOARRestart(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_keep);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_146setTOARRestart(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_keep) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTOARRestart", 0);

  /* "SLEPc/PEP.pyx":1381
 *         Allowed values are in the range [0.1,0.9]. The default is 0.5.
 *         """
 *         cdef PetscReal val = asReal(keep)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPTOARSetRestart(self.pep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_keep); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 1381, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1382
 *         """
 *         cdef PetscReal val = asReal(keep)
 *         CHKERR( PEPTOARSetRestart(self.pep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getTOARRestart(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPTOARSetRestart(__pyx_v_self->pep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1382, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1366
 *     #
 * 
 *     def setTOARRestart(self, keep):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the restart parameter for the TOAR method, in
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setTOARRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1384
 *         CHKERR( PEPTOARSetRestart(self.pep, val) )
 * 
 *     def getTOARRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the restart parameter used in the TOAR method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_149getTOARRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_148getTOARRestart[] = "PEP.getTOARRestart(self)\n\n        Gets the restart parameter used in the TOAR method.\n\n        Returns\n        -------\n        keep: float\n              The number of vectors to be kept at restart.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_149getTOARRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTOARRestart (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTOARRestart", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTOARRestart", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_148getTOARRestart(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_148getTOARRestart(struct PySlepcPEPObject *__pyx_v_self) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTOARRestart", 0);

  /* "SLEPc/PEP.pyx":1393
 *               The number of vectors to be kept at restart.
 *         """
 *         cdef PetscReal val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPTOARGetRestart(self.pep, &val) )
 *         return toReal(val)
 */
  __pyx_v_val = 0.0;

  /* "SLEPc/PEP.pyx":1394
 *         """
 *         cdef PetscReal val = 0
 *         CHKERR( PEPTOARGetRestart(self.pep, &val) )             # <<<<<<<<<<<<<<
 *         return toReal(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPTOARGetRestart(__pyx_v_self->pep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1394, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1395
 *         cdef PetscReal val = 0
 *         CHKERR( PEPTOARGetRestart(self.pep, &val) )
 *         return toReal(val)             # <<<<<<<<<<<<<<
 * 
 *     def setTOARLocking(self, lock):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1395, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1384
 *         CHKERR( PEPTOARSetRestart(self.pep, val) )
 * 
 *     def getTOARRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the restart parameter used in the TOAR method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getTOARRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1397
 *         return toReal(val)
 * 
 *     def setTOARLocking(self, lock):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between locking and non-locking variants of the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_151setTOARLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_150setTOARLocking[] = "PEP.setTOARLocking(self, lock)\n\n        Choose between locking and non-locking variants of the\n        TOAR method.\n\n        Parameters\n        ----------\n        lock: bool\n              True if the locking variant must be selected.\n\n        Notes\n        -----\n        The default is to lock converged eigenpairs when the method restarts.\n        This behaviour can be changed so that all directions are kept in the\n        working subspace even if already converged to working accuracy (the\n        non-locking variant).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_151setTOARLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_lock = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTOARLocking (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lock,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lock)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTOARLocking") < 0)) __PYX_ERR(19, 1397, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_lock = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTOARLocking", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1397, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setTOARLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_150setTOARLocking(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_lock);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_150setTOARLocking(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_lock) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTOARLocking", 0);

  /* "SLEPc/PEP.pyx":1414
 *         non-locking variant).
 *         """
 *         cdef PetscBool val = asBool(lock)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPTOARSetLocking(self.pep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_lock); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(19, 1414, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1415
 *         """
 *         cdef PetscBool val = asBool(lock)
 *         CHKERR( PEPTOARSetLocking(self.pep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getTOARLocking(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPTOARSetLocking(__pyx_v_self->pep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1415, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1397
 *         return toReal(val)
 * 
 *     def setTOARLocking(self, lock):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between locking and non-locking variants of the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setTOARLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1417
 *         CHKERR( PEPTOARSetLocking(self.pep, val) )
 * 
 *     def getTOARLocking(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the locking flag used in the TOAR method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_153getTOARLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_152getTOARLocking[] = "PEP.getTOARLocking(self)\n\n        Gets the locking flag used in the TOAR method.\n\n        Returns\n        -------\n        lock: bool\n              The locking flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_153getTOARLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTOARLocking (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTOARLocking", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTOARLocking", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_152getTOARLocking(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_152getTOARLocking(struct PySlepcPEPObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTOARLocking", 0);

  /* "SLEPc/PEP.pyx":1426
 *               The locking flag.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( PEPTOARGetLocking(self.pep, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/PEP.pyx":1427
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( PEPTOARGetLocking(self.pep, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPTOARGetLocking(__pyx_v_self->pep, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1427, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1428
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( PEPTOARGetLocking(self.pep, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1428, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1417
 *         CHKERR( PEPTOARSetLocking(self.pep, val) )
 * 
 *     def getTOARLocking(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the locking flag used in the TOAR method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getTOARLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1432
 *     #
 * 
 *     def setSTOARLinearization(self, alpha=1.0, beta=0.0):             # <<<<<<<<<<<<<<
 *         """
 *         Set the coefficients that define the linearization of a quadratic eigenproblem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_155setSTOARLinearization(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_154setSTOARLinearization[] = "PEP.setSTOARLinearization(self, alpha=1.0, beta=0.0)\n\n        Set the coefficients that define the linearization of a quadratic eigenproblem.\n\n        Parameters\n        ----------\n        alpha: float\n            First parameter of the linearization.\n        beta: float\n            Second parameter of the linearization.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_155setSTOARLinearization(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_alpha = 0;
  PyObject *__pyx_v_beta = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSTOARLinearization (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alpha,&__pyx_n_s_beta,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)__pyx_float_1_0);
    values[1] = ((PyObject *)__pyx_float_0_0);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_beta);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSTOARLinearization") < 0)) __PYX_ERR(19, 1432, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_alpha = values[0];
    __pyx_v_beta = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSTOARLinearization", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1432, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setSTOARLinearization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_154setSTOARLinearization(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_alpha, __pyx_v_beta);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_154setSTOARLinearization(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_alpha, PyObject *__pyx_v_beta) {
  PetscReal __pyx_v_a;
  PetscReal __pyx_v_b;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSTOARLinearization", 0);

  /* "SLEPc/PEP.pyx":1443
 *             Second parameter of the linearization.
 *         """
 *         cdef PetscReal a = asReal(alpha)             # <<<<<<<<<<<<<<
 *         cdef PetscReal b = asReal(beta)
 *         CHKERR( PEPSTOARSetLinearization(self.pep, a, b) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_alpha); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 1443, __pyx_L1_error)
  __pyx_v_a = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1444
 *         """
 *         cdef PetscReal a = asReal(alpha)
 *         cdef PetscReal b = asReal(beta)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSTOARSetLinearization(self.pep, a, b) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_beta); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 1444, __pyx_L1_error)
  __pyx_v_b = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1445
 *         cdef PetscReal a = asReal(alpha)
 *         cdef PetscReal b = asReal(beta)
 *         CHKERR( PEPSTOARSetLinearization(self.pep, a, b) )             # <<<<<<<<<<<<<<
 * 
 *     def getSTOARLinearization(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSTOARSetLinearization(__pyx_v_self->pep, __pyx_v_a, __pyx_v_b)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1445, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1432
 *     #
 * 
 *     def setSTOARLinearization(self, alpha=1.0, beta=0.0):             # <<<<<<<<<<<<<<
 *         """
 *         Set the coefficients that define the linearization of a quadratic eigenproblem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setSTOARLinearization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1447
 *         CHKERR( PEPSTOARSetLinearization(self.pep, a, b) )
 * 
 *     def getSTOARLinearization(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the coefficients that define the linearization of a quadratic eigenproblem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_157getSTOARLinearization(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_156getSTOARLinearization[] = "PEP.getSTOARLinearization(self)\n\n        Returns the coefficients that define the linearization of a quadratic eigenproblem.\n\n        Returns\n        -------\n        alpha: float\n            First parameter of the linearization.\n        beta: float\n            Second parameter of the linearization.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_157getSTOARLinearization(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSTOARLinearization (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSTOARLinearization", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSTOARLinearization", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_156getSTOARLinearization(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_156getSTOARLinearization(struct PySlepcPEPObject *__pyx_v_self) {
  PetscReal __pyx_v_a;
  PetscReal __pyx_v_b;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PetscReal __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSTOARLinearization", 0);

  /* "SLEPc/PEP.pyx":1458
 *             Second parameter of the linearization.
 *         """
 *         cdef PetscReal a = 0.0             # <<<<<<<<<<<<<<
 *         cdef PetscReal b = 0.0
 *         CHKERR( PEPSTOARGetLinearization(self.pep, &a, &b) )
 */
  __pyx_v_a = 0.0;

  /* "SLEPc/PEP.pyx":1459
 *         """
 *         cdef PetscReal a = 0.0
 *         cdef PetscReal b = 0.0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSTOARGetLinearization(self.pep, &a, &b) )
 *         return (asReal(a), asReal(b))
 */
  __pyx_v_b = 0.0;

  /* "SLEPc/PEP.pyx":1460
 *         cdef PetscReal a = 0.0
 *         cdef PetscReal b = 0.0
 *         CHKERR( PEPSTOARGetLinearization(self.pep, &a, &b) )             # <<<<<<<<<<<<<<
 *         return (asReal(a), asReal(b))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSTOARGetLinearization(__pyx_v_self->pep, (&__pyx_v_a), (&__pyx_v_b))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1460, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1461
 *         cdef PetscReal b = 0.0
 *         CHKERR( PEPSTOARGetLinearization(self.pep, &a, &b) )
 *         return (asReal(a), asReal(b))             # <<<<<<<<<<<<<<
 * 
 *     def setSTOARLocking(self, lock):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_a); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1461, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_t_2); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 1461, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1461, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_b); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 1461, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_t_4); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 1461, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = PyFloat_FromDouble(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 1461, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(19, 1461, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
  __pyx_t_2 = 0;
  __pyx_t_4 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1447
 *         CHKERR( PEPSTOARSetLinearization(self.pep, a, b) )
 * 
 *     def getSTOARLinearization(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the coefficients that define the linearization of a quadratic eigenproblem.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getSTOARLinearization", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1463
 *         return (asReal(a), asReal(b))
 * 
 *     def setSTOARLocking(self, lock):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between locking and non-locking variants of the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_159setSTOARLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_158setSTOARLocking[] = "PEP.setSTOARLocking(self, lock)\n\n        Choose between locking and non-locking variants of the\n        STOAR method.\n\n        Parameters\n        ----------\n        lock: bool\n              True if the locking variant must be selected.\n\n        Notes\n        -----\n        The default is to lock converged eigenpairs when the method restarts.\n        This behaviour can be changed so that all directions are kept in the\n        working subspace even if already converged to working accuracy (the\n        non-locking variant).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_159setSTOARLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_lock = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSTOARLocking (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lock,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lock)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSTOARLocking") < 0)) __PYX_ERR(19, 1463, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_lock = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSTOARLocking", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1463, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setSTOARLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_158setSTOARLocking(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_lock);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_158setSTOARLocking(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_lock) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSTOARLocking", 0);

  /* "SLEPc/PEP.pyx":1480
 *         non-locking variant).
 *         """
 *         cdef PetscBool val = asBool(lock)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSTOARSetLocking(self.pep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_lock); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(19, 1480, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1481
 *         """
 *         cdef PetscBool val = asBool(lock)
 *         CHKERR( PEPSTOARSetLocking(self.pep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getSTOARLocking(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSTOARSetLocking(__pyx_v_self->pep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1481, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1463
 *         return (asReal(a), asReal(b))
 * 
 *     def setSTOARLocking(self, lock):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between locking and non-locking variants of the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setSTOARLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1483
 *         CHKERR( PEPSTOARSetLocking(self.pep, val) )
 * 
 *     def getSTOARLocking(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the locking flag used in the STOAR method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_161getSTOARLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_160getSTOARLocking[] = "PEP.getSTOARLocking(self)\n\n        Gets the locking flag used in the STOAR method.\n\n        Returns\n        -------\n        lock: bool\n              The locking flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_161getSTOARLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSTOARLocking (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSTOARLocking", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSTOARLocking", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_160getSTOARLocking(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_160getSTOARLocking(struct PySlepcPEPObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSTOARLocking", 0);

  /* "SLEPc/PEP.pyx":1492
 *               The locking flag.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSTOARGetLocking(self.pep, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/PEP.pyx":1493
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( PEPSTOARGetLocking(self.pep, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSTOARGetLocking(__pyx_v_self->pep, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1493, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1494
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( PEPSTOARGetLocking(self.pep, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setSTOARDetectZeros(self, detect):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1494, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1483
 *         CHKERR( PEPSTOARSetLocking(self.pep, val) )
 * 
 *     def getSTOARLocking(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the locking flag used in the STOAR method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getSTOARLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1496
 *         return toBool(tval)
 * 
 *     def setSTOARDetectZeros(self, detect):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to enforce detection of zeros during the factorizations
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_163setSTOARDetectZeros(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_162setSTOARDetectZeros[] = "PEP.setSTOARDetectZeros(self, detect)\n\n        Sets a flag to enforce detection of zeros during the factorizations\n        throughout the spectrum slicing computation.\n\n        Parameters\n        ----------\n        detect: bool\n              True if zeros must checked for.\n\n        Notes\n        -----\n        A zero in the factorization indicates that a shift coincides with\n        an eigenvalue.\n\n        This flag is turned off by default, and may be necessary in some cases.\n        This feature currently requires an external package for factorizations\n        with support for zero detection, e.g. MUMPS.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_163setSTOARDetectZeros(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_detect = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSTOARDetectZeros (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_detect,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_detect)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSTOARDetectZeros") < 0)) __PYX_ERR(19, 1496, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_detect = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSTOARDetectZeros", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1496, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setSTOARDetectZeros", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_162setSTOARDetectZeros(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_detect);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_162setSTOARDetectZeros(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_detect) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSTOARDetectZeros", 0);

  /* "SLEPc/PEP.pyx":1515
 *         with support for zero detection, e.g. MUMPS.
 *         """
 *         cdef PetscBool val = asBool(detect)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSTOARSetDetectZeros(self.pep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_detect); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(19, 1515, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1516
 *         """
 *         cdef PetscBool val = asBool(detect)
 *         CHKERR( PEPSTOARSetDetectZeros(self.pep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getSTOARDetectZeros(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSTOARSetDetectZeros(__pyx_v_self->pep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1516, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1496
 *         return toBool(tval)
 * 
 *     def setSTOARDetectZeros(self, detect):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to enforce detection of zeros during the factorizations
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setSTOARDetectZeros", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1518
 *         CHKERR( PEPSTOARSetDetectZeros(self.pep, val) )
 * 
 *     def getSTOARDetectZeros(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the flag that enforces zero detection in spectrum slicing.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_165getSTOARDetectZeros(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_164getSTOARDetectZeros[] = "PEP.getSTOARDetectZeros(self)\n\n        Gets the flag that enforces zero detection in spectrum slicing.\n\n        Returns\n        -------\n        detect: bool\n              The zero detection flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_165getSTOARDetectZeros(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSTOARDetectZeros (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSTOARDetectZeros", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSTOARDetectZeros", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_164getSTOARDetectZeros(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_164getSTOARDetectZeros(struct PySlepcPEPObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSTOARDetectZeros", 0);

  /* "SLEPc/PEP.pyx":1527
 *               The zero detection flag.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSTOARGetDetectZeros(self.pep, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/PEP.pyx":1528
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( PEPSTOARGetDetectZeros(self.pep, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSTOARGetDetectZeros(__pyx_v_self->pep, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1528, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1529
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( PEPSTOARGetDetectZeros(self.pep, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setSTOARDimensions(self, nev=None, ncv=None, mpd=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1529, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1518
 *         CHKERR( PEPSTOARSetDetectZeros(self.pep, val) )
 * 
 *     def getSTOARDetectZeros(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the flag that enforces zero detection in spectrum slicing.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getSTOARDetectZeros", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1531
 *         return toBool(tval)
 * 
 *     def setSTOARDimensions(self, nev=None, ncv=None, mpd=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the dimensions used for each subsolve step in case of doing
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_167setSTOARDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_166setSTOARDimensions[] = "PEP.setSTOARDimensions(self, nev=None, ncv=None, mpd=None)\n\n        Sets the dimensions used for each subsolve step in case of doing\n        spectrum slicing for a computational interval. The meaning of the\n        parameters is the same as in `setDimensions()`.\n\n        Parameters\n        ----------\n        nev: int, optional\n             Number of eigenvalues to compute.\n        ncv: int, optional\n             Maximum dimension of the subspace to be used by the solver.\n        mpd: int, optional\n             Maximum dimension allowed for the projected problem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_167setSTOARDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nev = 0;
  PyObject *__pyx_v_ncv = 0;
  PyObject *__pyx_v_mpd = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSTOARDimensions (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nev,&__pyx_n_s_ncv,&__pyx_n_s_mpd,0};
    PyObject* values[3] = {0,0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nev);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ncv);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mpd);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSTOARDimensions") < 0)) __PYX_ERR(19, 1531, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_nev = values[0];
    __pyx_v_ncv = values[1];
    __pyx_v_mpd = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSTOARDimensions", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1531, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setSTOARDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_166setSTOARDimensions(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_nev, __pyx_v_ncv, __pyx_v_mpd);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_166setSTOARDimensions(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_nev, PyObject *__pyx_v_ncv, PyObject *__pyx_v_mpd) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSTOARDimensions", 0);

  /* "SLEPc/PEP.pyx":1546
 *              Maximum dimension allowed for the projected problem.
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":1547
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":1548
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)
 */
  __pyx_v_ival3 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":1549
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)             # <<<<<<<<<<<<<<
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)
 */
  __pyx_t_1 = (__pyx_v_nev != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_nev); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 1549, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_3;
  }

  /* "SLEPc/PEP.pyx":1550
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)             # <<<<<<<<<<<<<<
 *         if mpd is not None: ival3 = asInt(mpd)
 *         CHKERR( PEPSTOARSetDimensions(self.pep, ival1, ival2, ival3) )
 */
  __pyx_t_2 = (__pyx_v_ncv != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_ncv); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 1550, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_3;
  }

  /* "SLEPc/PEP.pyx":1551
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSTOARSetDimensions(self.pep, ival1, ival2, ival3) )
 * 
 */
  __pyx_t_1 = (__pyx_v_mpd != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_mpd); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 1551, __pyx_L1_error)
    __pyx_v_ival3 = __pyx_t_3;
  }

  /* "SLEPc/PEP.pyx":1552
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)
 *         CHKERR( PEPSTOARSetDimensions(self.pep, ival1, ival2, ival3) )             # <<<<<<<<<<<<<<
 * 
 *     def getSTOARDimensions(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSTOARSetDimensions(__pyx_v_self->pep, __pyx_v_ival1, __pyx_v_ival2, __pyx_v_ival3)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(19, 1552, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1531
 *         return toBool(tval)
 * 
 *     def setSTOARDimensions(self, nev=None, ncv=None, mpd=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the dimensions used for each subsolve step in case of doing
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setSTOARDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1554
 *         CHKERR( PEPSTOARSetDimensions(self.pep, ival1, ival2, ival3) )
 * 
 *     def getSTOARDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the dimensions used for each subsolve step in case of doing
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_169getSTOARDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_168getSTOARDimensions[] = "PEP.getSTOARDimensions(self)\n\n        Gets the dimensions used for each subsolve step in case of doing\n        spectrum slicing for a computational interval.\n\n        Returns\n        -------\n        nev: int\n             Number of eigenvalues to compute.\n        ncv: int\n             Maximum dimension of the subspace to be used by the solver.\n        mpd: int\n             Maximum dimension allowed for the projected problem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_169getSTOARDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSTOARDimensions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSTOARDimensions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSTOARDimensions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_168getSTOARDimensions(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_168getSTOARDimensions(struct PySlepcPEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSTOARDimensions", 0);

  /* "SLEPc/PEP.pyx":1568
 *              Maximum dimension allowed for the projected problem.
 *         """
 *         cdef PetscInt ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/PEP.pyx":1569
 *         """
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival3 = 0
 *         CHKERR( PEPSTOARGetDimensions(self.pep, &ival1, &ival2, &ival3) )
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/PEP.pyx":1570
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSTOARGetDimensions(self.pep, &ival1, &ival2, &ival3) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 */
  __pyx_v_ival3 = 0;

  /* "SLEPc/PEP.pyx":1571
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 *         CHKERR( PEPSTOARGetDimensions(self.pep, &ival1, &ival2, &ival3) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSTOARGetDimensions(__pyx_v_self->pep, (&__pyx_v_ival1), (&__pyx_v_ival2), (&__pyx_v_ival3))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1571, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1572
 *         cdef PetscInt ival3 = 0
 *         CHKERR( PEPSTOARGetDimensions(self.pep, &ival1, &ival2, &ival3) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))             # <<<<<<<<<<<<<<
 * 
 *     def getSTOARInertias(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1572, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 1572, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival3); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 1572, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(19, 1572, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1554
 *         CHKERR( PEPSTOARSetDimensions(self.pep, ival1, ival2, ival3) )
 * 
 *     def getSTOARDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the dimensions used for each subsolve step in case of doing
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getSTOARDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1574
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 *     def getSTOARInertias(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of the shifts and their corresponding inertias
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_171getSTOARInertias(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_170getSTOARInertias[] = "PEP.getSTOARInertias(self)\n\n        Gets the values of the shifts and their corresponding inertias\n        in case of doing spectrum slicing for a computational interval.\n\n        Returns\n        -------\n        shifts: list of float\n             The values of the shifts used internally in the solver.\n        inertias: list of int\n             The values of the inertia in each shift.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_171getSTOARInertias(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSTOARInertias (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSTOARInertias", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSTOARInertias", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_170getSTOARInertias(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_170getSTOARInertias(struct PySlepcPEPObject *__pyx_v_self) {
  PetscReal *__pyx_v_shiftsarray;
  PetscInt *__pyx_v_inertiasarray;
  PetscInt __pyx_v_n;
  PyObject *__pyx_v_shifts = 0;
  PyObject *__pyx_v_inertias = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  char const *__pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  PyObject *__pyx_t_10 = NULL;
  int __pyx_t_11;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSTOARInertias", 0);

  /* "SLEPc/PEP.pyx":1586
 *              The values of the inertia in each shift.
 *         """
 *         cdef PetscReal *shiftsarray = NULL             # <<<<<<<<<<<<<<
 *         cdef PetscInt *inertiasarray = NULL
 *         cdef PetscInt n = 0
 */
  __pyx_v_shiftsarray = NULL;

  /* "SLEPc/PEP.pyx":1587
 *         """
 *         cdef PetscReal *shiftsarray = NULL
 *         cdef PetscInt *inertiasarray = NULL             # <<<<<<<<<<<<<<
 *         cdef PetscInt n = 0
 *         CHKERR(PEPSTOARGetInertias(self.pep, &n, &shiftsarray, &inertiasarray))
 */
  __pyx_v_inertiasarray = NULL;

  /* "SLEPc/PEP.pyx":1588
 *         cdef PetscReal *shiftsarray = NULL
 *         cdef PetscInt *inertiasarray = NULL
 *         cdef PetscInt n = 0             # <<<<<<<<<<<<<<
 *         CHKERR(PEPSTOARGetInertias(self.pep, &n, &shiftsarray, &inertiasarray))
 *         cdef object shifts = None
 */
  __pyx_v_n = 0;

  /* "SLEPc/PEP.pyx":1589
 *         cdef PetscInt *inertiasarray = NULL
 *         cdef PetscInt n = 0
 *         CHKERR(PEPSTOARGetInertias(self.pep, &n, &shiftsarray, &inertiasarray))             # <<<<<<<<<<<<<<
 *         cdef object shifts = None
 *         cdef object inertias = None
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSTOARGetInertias(__pyx_v_self->pep, (&__pyx_v_n), (&__pyx_v_shiftsarray), (&__pyx_v_inertiasarray))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1589, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1590
 *         cdef PetscInt n = 0
 *         CHKERR(PEPSTOARGetInertias(self.pep, &n, &shiftsarray, &inertiasarray))
 *         cdef object shifts = None             # <<<<<<<<<<<<<<
 *         cdef object inertias = None
 *         try:
 */
  __Pyx_INCREF(Py_None);
  __pyx_v_shifts = Py_None;

  /* "SLEPc/PEP.pyx":1591
 *         CHKERR(PEPSTOARGetInertias(self.pep, &n, &shiftsarray, &inertiasarray))
 *         cdef object shifts = None
 *         cdef object inertias = None             # <<<<<<<<<<<<<<
 *         try:
 *             shifts = array_r(n, shiftsarray)
 */
  __Pyx_INCREF(Py_None);
  __pyx_v_inertias = Py_None;

  /* "SLEPc/PEP.pyx":1592
 *         cdef object shifts = None
 *         cdef object inertias = None
 *         try:             # <<<<<<<<<<<<<<
 *             shifts = array_r(n, shiftsarray)
 *             inertias = array_i(n, inertiasarray)
 */
  /*try:*/ {

    /* "SLEPc/PEP.pyx":1593
 *         cdef object inertias = None
 *         try:
 *             shifts = array_r(n, shiftsarray)             # <<<<<<<<<<<<<<
 *             inertias = array_i(n, inertiasarray)
 *         finally:
 */
    __pyx_t_2 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_r(__pyx_v_n, __pyx_v_shiftsarray)); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1593, __pyx_L4_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_shifts, __pyx_t_2);
    __pyx_t_2 = 0;

    /* "SLEPc/PEP.pyx":1594
 *         try:
 *             shifts = array_r(n, shiftsarray)
 *             inertias = array_i(n, inertiasarray)             # <<<<<<<<<<<<<<
 *         finally:
 *             CHKERR( PetscFree(shiftsarray) )
 */
    __pyx_t_2 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_i(__pyx_v_n, __pyx_v_inertiasarray)); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1594, __pyx_L4_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_inertias, __pyx_t_2);
    __pyx_t_2 = 0;
  }

  /* "SLEPc/PEP.pyx":1596
 *             inertias = array_i(n, inertiasarray)
 *         finally:
 *             CHKERR( PetscFree(shiftsarray) )             # <<<<<<<<<<<<<<
 *             CHKERR( PetscFree(inertiasarray) )
 *         return (shifts, inertias)
 */
  /*finally:*/ {
    /*normal exit:*/{
      __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_shiftsarray)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1596, __pyx_L1_error)

      /* "SLEPc/PEP.pyx":1597
 *         finally:
 *             CHKERR( PetscFree(shiftsarray) )
 *             CHKERR( PetscFree(inertiasarray) )             # <<<<<<<<<<<<<<
 *         return (shifts, inertias)
 * 
 */
      __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_inertiasarray)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1597, __pyx_L1_error)
      goto __pyx_L5;
    }
    __pyx_L4_error:;
    /*exception exit:*/{
      __Pyx_PyThreadState_declare
      __Pyx_PyThreadState_assign
      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_5);
      __Pyx_XGOTREF(__pyx_t_6);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_8);
      __Pyx_XGOTREF(__pyx_t_9);
      __Pyx_XGOTREF(__pyx_t_10);
      __pyx_t_1 = __pyx_lineno; __pyx_t_3 = __pyx_clineno; __pyx_t_4 = __pyx_filename;
      {

        /* "SLEPc/PEP.pyx":1596
 *             inertias = array_i(n, inertiasarray)
 *         finally:
 *             CHKERR( PetscFree(shiftsarray) )             # <<<<<<<<<<<<<<
 *             CHKERR( PetscFree(inertiasarray) )
 *         return (shifts, inertias)
 */
        __pyx_t_11 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_shiftsarray)); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(19, 1596, __pyx_L7_error)

        /* "SLEPc/PEP.pyx":1597
 *         finally:
 *             CHKERR( PetscFree(shiftsarray) )
 *             CHKERR( PetscFree(inertiasarray) )             # <<<<<<<<<<<<<<
 *         return (shifts, inertias)
 * 
 */
        __pyx_t_11 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_inertiasarray)); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(19, 1597, __pyx_L7_error)
      }
      if (PY_MAJOR_VERSION >= 3) {
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
      }
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_XGIVEREF(__pyx_t_7);
      __Pyx_ErrRestore(__pyx_t_5, __pyx_t_6, __pyx_t_7);
      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      __pyx_lineno = __pyx_t_1; __pyx_clineno = __pyx_t_3; __pyx_filename = __pyx_t_4;
      goto __pyx_L1_error;
      __pyx_L7_error:;
      if (PY_MAJOR_VERSION >= 3) {
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
      }
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      goto __pyx_L1_error;
    }
    __pyx_L5:;
  }

  /* "SLEPc/PEP.pyx":1598
 *             CHKERR( PetscFree(shiftsarray) )
 *             CHKERR( PetscFree(inertiasarray) )
 *         return (shifts, inertias)             # <<<<<<<<<<<<<<
 * 
 *     def setSTOARCheckEigenvalueType(self, flag):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1598, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_v_shifts);
  __Pyx_GIVEREF(__pyx_v_shifts);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shifts);
  __Pyx_INCREF(__pyx_v_inertias);
  __Pyx_GIVEREF(__pyx_v_inertias);
  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_inertias);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1574
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 *     def getSTOARInertias(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of the shifts and their corresponding inertias
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getSTOARInertias", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_shifts);
  __Pyx_XDECREF(__pyx_v_inertias);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1600
 *         return (shifts, inertias)
 * 
 *     def setSTOARCheckEigenvalueType(self, flag):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to check that all the eigenvalues obtained throughout
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_173setSTOARCheckEigenvalueType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_172setSTOARCheckEigenvalueType[] = "PEP.setSTOARCheckEigenvalueType(self, flag)\n\n        Sets a flag to check that all the eigenvalues obtained throughout\n        the spectrum slicing computation have the same definite type.\n\n        Parameters\n        ----------\n        flag: bool\n            Whether the eigenvalue type is checked or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_173setSTOARCheckEigenvalueType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_flag = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSTOARCheckEigenvalueType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flag,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flag)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSTOARCheckEigenvalueType") < 0)) __PYX_ERR(19, 1600, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_flag = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSTOARCheckEigenvalueType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1600, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setSTOARCheckEigenvalueType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_172setSTOARCheckEigenvalueType(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_flag);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_172setSTOARCheckEigenvalueType(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_flag) {
  PetscBool __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSTOARCheckEigenvalueType", 0);

  /* "SLEPc/PEP.pyx":1610
 *             Whether the eigenvalue type is checked or not.
 *         """
 *         cdef PetscBool sval = asBool(flag)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSTOARSetCheckEigenvalueType(self.pep, sval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_flag); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(19, 1610, __pyx_L1_error)
  __pyx_v_sval = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1611
 *         """
 *         cdef PetscBool sval = asBool(flag)
 *         CHKERR( PEPSTOARSetCheckEigenvalueType(self.pep, sval) )             # <<<<<<<<<<<<<<
 * 
 *     def getSTOARCheckEigenvalueType(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSTOARSetCheckEigenvalueType(__pyx_v_self->pep, __pyx_v_sval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1611, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1600
 *         return (shifts, inertias)
 * 
 *     def setSTOARCheckEigenvalueType(self, flag):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to check that all the eigenvalues obtained throughout
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setSTOARCheckEigenvalueType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1613
 *         CHKERR( PEPSTOARSetCheckEigenvalueType(self.pep, sval) )
 * 
 *     def getSTOARCheckEigenvalueType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the flag for the eigenvalue type check in spectrum slicing.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_175getSTOARCheckEigenvalueType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_174getSTOARCheckEigenvalueType[] = "PEP.getSTOARCheckEigenvalueType(self)\n\n        Gets the flag for the eigenvalue type check in spectrum slicing.\n\n        Returns\n        -------\n        flag: bool\n            Whether the eigenvalue type is checked or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_175getSTOARCheckEigenvalueType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSTOARCheckEigenvalueType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSTOARCheckEigenvalueType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSTOARCheckEigenvalueType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_174getSTOARCheckEigenvalueType(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_174getSTOARCheckEigenvalueType(struct PySlepcPEPObject *__pyx_v_self) {
  PetscBool __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSTOARCheckEigenvalueType", 0);

  /* "SLEPc/PEP.pyx":1622
 *             Whether the eigenvalue type is checked or not.
 *         """
 *         cdef PetscBool sval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( PEPSTOARGetCheckEigenvalueType(self.pep, &sval) )
 *         return toBool(sval)
 */
  __pyx_v_sval = PETSC_FALSE;

  /* "SLEPc/PEP.pyx":1623
 *         """
 *         cdef PetscBool sval = PETSC_FALSE
 *         CHKERR( PEPSTOARGetCheckEigenvalueType(self.pep, &sval) )             # <<<<<<<<<<<<<<
 *         return toBool(sval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPSTOARGetCheckEigenvalueType(__pyx_v_self->pep, (&__pyx_v_sval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1623, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1624
 *         cdef PetscBool sval = PETSC_FALSE
 *         CHKERR( PEPSTOARGetCheckEigenvalueType(self.pep, &sval) )
 *         return toBool(sval)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_sval); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1624, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1613
 *         CHKERR( PEPSTOARSetCheckEigenvalueType(self.pep, sval) )
 * 
 *     def getSTOARCheckEigenvalueType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the flag for the eigenvalue type check in spectrum slicing.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getSTOARCheckEigenvalueType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1628
 *     #
 * 
 *     def setJDRestart(self, keep):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the restart parameter for the Jacobi-Davidson method, in
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_177setJDRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_176setJDRestart[] = "PEP.setJDRestart(self, keep)\n\n        Sets the restart parameter for the Jacobi-Davidson method, in\n        particular the proportion of basis vectors that must be kept\n        after restart.\n\n        Parameters\n        ----------\n        keep: float\n              The number of vectors to be kept at restart.\n\n        Notes\n        -----\n        Allowed values are in the range [0.1,0.9]. The default is 0.5.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_177setJDRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_keep = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setJDRestart (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_keep,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_keep)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setJDRestart") < 0)) __PYX_ERR(19, 1628, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_keep = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setJDRestart", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1628, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setJDRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_176setJDRestart(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_keep);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_176setJDRestart(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_keep) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setJDRestart", 0);

  /* "SLEPc/PEP.pyx":1643
 *         Allowed values are in the range [0.1,0.9]. The default is 0.5.
 *         """
 *         cdef PetscReal val = asReal(keep)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPJDSetRestart(self.pep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_keep); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 1643, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1644
 *         """
 *         cdef PetscReal val = asReal(keep)
 *         CHKERR( PEPJDSetRestart(self.pep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getJDRestart(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPJDSetRestart(__pyx_v_self->pep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1644, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1628
 *     #
 * 
 *     def setJDRestart(self, keep):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the restart parameter for the Jacobi-Davidson method, in
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setJDRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1646
 *         CHKERR( PEPJDSetRestart(self.pep, val) )
 * 
 *     def getJDRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the restart parameter used in the Jacobi-Davidson method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_179getJDRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_178getJDRestart[] = "PEP.getJDRestart(self)\n\n        Gets the restart parameter used in the Jacobi-Davidson method.\n\n        Returns\n        -------\n        keep: float\n              The number of vectors to be kept at restart.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_179getJDRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getJDRestart (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getJDRestart", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getJDRestart", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_178getJDRestart(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_178getJDRestart(struct PySlepcPEPObject *__pyx_v_self) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getJDRestart", 0);

  /* "SLEPc/PEP.pyx":1655
 *               The number of vectors to be kept at restart.
 *         """
 *         cdef PetscReal val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPJDGetRestart(self.pep, &val) )
 *         return toReal(val)
 */
  __pyx_v_val = 0.0;

  /* "SLEPc/PEP.pyx":1656
 *         """
 *         cdef PetscReal val = 0
 *         CHKERR( PEPJDGetRestart(self.pep, &val) )             # <<<<<<<<<<<<<<
 *         return toReal(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPJDGetRestart(__pyx_v_self->pep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1656, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1657
 *         cdef PetscReal val = 0
 *         CHKERR( PEPJDGetRestart(self.pep, &val) )
 *         return toReal(val)             # <<<<<<<<<<<<<<
 * 
 *     def setJDFix(self, fix):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1657, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1646
 *         CHKERR( PEPJDSetRestart(self.pep, val) )
 * 
 *     def getJDRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the restart parameter used in the Jacobi-Davidson method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getJDRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1659
 *         return toReal(val)
 * 
 *     def setJDFix(self, fix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the threshold for changing the target in the correction
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_181setJDFix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_180setJDFix[] = "PEP.setJDFix(self, fix)\n\n        Sets the threshold for changing the target in the correction\n        equation.\n\n        Parameters\n        ----------\n        fix: float\n              Threshold for changing the target.\n\n        Notes\n        -----\n        The target in the correction equation is fixed at the first iterations.\n        When the norm of the residual vector is lower than the fix value,\n        the target is set to the corresponding eigenvalue.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_181setJDFix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_fix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setJDFix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setJDFix") < 0)) __PYX_ERR(19, 1659, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_fix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setJDFix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1659, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setJDFix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_180setJDFix(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_fix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_180setJDFix(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_fix) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setJDFix", 0);

  /* "SLEPc/PEP.pyx":1675
 *         the target is set to the corresponding eigenvalue.
 *         """
 *         cdef PetscReal val = asReal(fix)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPJDSetFix(self.pep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_fix); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 1675, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1676
 *         """
 *         cdef PetscReal val = asReal(fix)
 *         CHKERR( PEPJDSetFix(self.pep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getJDFix(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPJDSetFix(__pyx_v_self->pep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1676, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1659
 *         return toReal(val)
 * 
 *     def setJDFix(self, fix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the threshold for changing the target in the correction
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setJDFix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1678
 *         CHKERR( PEPJDSetFix(self.pep, val) )
 * 
 *     def getJDFix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets threshold for changing the target in the correction equation.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_183getJDFix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_182getJDFix[] = "PEP.getJDFix(self)\n\n        Gets threshold for changing the target in the correction equation.\n\n        Returns\n        -------\n        fix: float\n              The threshold for changing the target.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_183getJDFix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getJDFix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getJDFix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getJDFix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_182getJDFix(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_182getJDFix(struct PySlepcPEPObject *__pyx_v_self) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getJDFix", 0);

  /* "SLEPc/PEP.pyx":1687
 *               The threshold for changing the target.
 *         """
 *         cdef PetscReal val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPJDGetFix(self.pep, &val) )
 *         return toReal(val)
 */
  __pyx_v_val = 0.0;

  /* "SLEPc/PEP.pyx":1688
 *         """
 *         cdef PetscReal val = 0
 *         CHKERR( PEPJDGetFix(self.pep, &val) )             # <<<<<<<<<<<<<<
 *         return toReal(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPJDGetFix(__pyx_v_self->pep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1688, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1689
 *         cdef PetscReal val = 0
 *         CHKERR( PEPJDGetFix(self.pep, &val) )
 *         return toReal(val)             # <<<<<<<<<<<<<<
 * 
 *     def setJDReusePreconditioner(self, flag):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1689, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1678
 *         CHKERR( PEPJDSetFix(self.pep, val) )
 * 
 *     def getJDFix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets threshold for changing the target in the correction equation.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getJDFix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1691
 *         return toReal(val)
 * 
 *     def setJDReusePreconditioner(self, flag):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag indicating whether the preconditioner must be reused or not.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_185setJDReusePreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_184setJDReusePreconditioner[] = "PEP.setJDReusePreconditioner(self, flag)\n\n        Sets a flag indicating whether the preconditioner must be reused or not.\n\n        Parameters\n        ----------\n        flag: bool\n            The reuse flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_185setJDReusePreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_flag = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setJDReusePreconditioner (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flag,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flag)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setJDReusePreconditioner") < 0)) __PYX_ERR(19, 1691, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_flag = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setJDReusePreconditioner", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1691, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setJDReusePreconditioner", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_184setJDReusePreconditioner(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_flag);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_184setJDReusePreconditioner(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_flag) {
  PetscBool __pyx_v_bval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setJDReusePreconditioner", 0);

  /* "SLEPc/PEP.pyx":1700
 *             The reuse flag.
 *         """
 *         cdef PetscBool bval = asBool(flag)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPJDSetReusePreconditioner(self.pep, bval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_flag); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(19, 1700, __pyx_L1_error)
  __pyx_v_bval = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1701
 *         """
 *         cdef PetscBool bval = asBool(flag)
 *         CHKERR( PEPJDSetReusePreconditioner(self.pep, bval) )             # <<<<<<<<<<<<<<
 * 
 *     def getJDReusePreconditioner(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPJDSetReusePreconditioner(__pyx_v_self->pep, __pyx_v_bval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1701, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1691
 *         return toReal(val)
 * 
 *     def setJDReusePreconditioner(self, flag):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag indicating whether the preconditioner must be reused or not.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setJDReusePreconditioner", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1703
 *         CHKERR( PEPJDSetReusePreconditioner(self.pep, bval) )
 * 
 *     def getJDReusePreconditioner(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag for reusing the preconditioner.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_187getJDReusePreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_186getJDReusePreconditioner[] = "PEP.getJDReusePreconditioner(self)\n\n        Returns the flag for reusing the preconditioner.\n\n        Returns\n        -------\n        flag: bool\n            The reuse flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_187getJDReusePreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getJDReusePreconditioner (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getJDReusePreconditioner", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getJDReusePreconditioner", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_186getJDReusePreconditioner(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_186getJDReusePreconditioner(struct PySlepcPEPObject *__pyx_v_self) {
  PetscBool __pyx_v_bval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getJDReusePreconditioner", 0);

  /* "SLEPc/PEP.pyx":1712
 *             The reuse flag.
 *         """
 *         cdef PetscBool bval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( PEPJDGetReusePreconditioner(self.pep, &bval) )
 *         return toBool(bval)
 */
  __pyx_v_bval = PETSC_FALSE;

  /* "SLEPc/PEP.pyx":1713
 *         """
 *         cdef PetscBool bval = PETSC_FALSE
 *         CHKERR( PEPJDGetReusePreconditioner(self.pep, &bval) )             # <<<<<<<<<<<<<<
 *         return toBool(bval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPJDGetReusePreconditioner(__pyx_v_self->pep, (&__pyx_v_bval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1713, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1714
 *         cdef PetscBool bval = PETSC_FALSE
 *         CHKERR( PEPJDGetReusePreconditioner(self.pep, &bval) )
 *         return toBool(bval)             # <<<<<<<<<<<<<<
 * 
 *     def setJDMinimalityIndex(self, flag):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_bval); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1714, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1703
 *         CHKERR( PEPJDSetReusePreconditioner(self.pep, bval) )
 * 
 *     def getJDReusePreconditioner(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag for reusing the preconditioner.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getJDReusePreconditioner", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1716
 *         return toBool(bval)
 * 
 *     def setJDMinimalityIndex(self, flag):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the maximum allowed value for the minimality index.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_189setJDMinimalityIndex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_188setJDMinimalityIndex[] = "PEP.setJDMinimalityIndex(self, flag)\n\n        Sets the maximum allowed value for the minimality index.\n\n        Parameters\n        ----------\n        flag: int\n            The maximum minimality index.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_189setJDMinimalityIndex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_flag = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setJDMinimalityIndex (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flag,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flag)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setJDMinimalityIndex") < 0)) __PYX_ERR(19, 1716, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_flag = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setJDMinimalityIndex", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1716, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setJDMinimalityIndex", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_188setJDMinimalityIndex(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_flag);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_188setJDMinimalityIndex(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_flag) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setJDMinimalityIndex", 0);

  /* "SLEPc/PEP.pyx":1725
 *             The maximum minimality index.
 *         """
 *         cdef PetscInt ival = asInt(flag)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPJDSetMinimalityIndex(self.pep, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_flag); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 1725, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1726
 *         """
 *         cdef PetscInt ival = asInt(flag)
 *         CHKERR( PEPJDSetMinimalityIndex(self.pep, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getJDMinimalityIndex(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPJDSetMinimalityIndex(__pyx_v_self->pep, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1726, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1716
 *         return toBool(bval)
 * 
 *     def setJDMinimalityIndex(self, flag):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the maximum allowed value for the minimality index.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setJDMinimalityIndex", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1728
 *         CHKERR( PEPJDSetMinimalityIndex(self.pep, ival) )
 * 
 *     def getJDMinimalityIndex(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the maximum allowed value of the minimality index.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_191getJDMinimalityIndex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_190getJDMinimalityIndex[] = "PEP.getJDMinimalityIndex(self)\n\n        Returns the maximum allowed value of the minimality index.\n\n        Returns\n        -------\n        flag: int\n            The maximum minimality index.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_191getJDMinimalityIndex(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getJDMinimalityIndex (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getJDMinimalityIndex", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getJDMinimalityIndex", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_190getJDMinimalityIndex(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_190getJDMinimalityIndex(struct PySlepcPEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getJDMinimalityIndex", 0);

  /* "SLEPc/PEP.pyx":1737
 *             The maximum minimality index.
 *         """
 *         cdef PetscInt ival = 1             # <<<<<<<<<<<<<<
 *         CHKERR( PEPJDGetMinimalityIndex(self.pep, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 1;

  /* "SLEPc/PEP.pyx":1738
 *         """
 *         cdef PetscInt ival = 1
 *         CHKERR( PEPJDGetMinimalityIndex(self.pep, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPJDGetMinimalityIndex(__pyx_v_self->pep, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1738, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1739
 *         cdef PetscInt ival = 1
 *         CHKERR( PEPJDGetMinimalityIndex(self.pep, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def setJDProjection(self, proj):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1739, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1728
 *         CHKERR( PEPJDSetMinimalityIndex(self.pep, ival) )
 * 
 *     def getJDMinimalityIndex(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the maximum allowed value of the minimality index.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getJDMinimalityIndex", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1741
 *         return toInt(ival)
 * 
 *     def setJDProjection(self, proj):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the type of projection to be used in the Jacobi-Davidson solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_193setJDProjection(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_192setJDProjection[] = "PEP.setJDProjection(self, proj)\n\n        Sets the type of projection to be used in the Jacobi-Davidson solver.\n\n        Parameters\n        ----------\n        proj: `PEP.JDProjection` enumerate\n               The type of projection.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_193setJDProjection(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_proj = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setJDProjection (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_proj,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_proj)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setJDProjection") < 0)) __PYX_ERR(19, 1741, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_proj = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setJDProjection", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1741, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setJDProjection", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_192setJDProjection(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_proj);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_192setJDProjection(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_proj) {
  PEPJDProjection __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PEPJDProjection __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setJDProjection", 0);

  /* "SLEPc/PEP.pyx":1750
 *                The type of projection.
 *         """
 *         cdef SlepcPEPJDProjection val = proj             # <<<<<<<<<<<<<<
 *         CHKERR( PEPJDSetProjection(self.pep, val) )
 * 
 */
  __pyx_t_1 = ((PEPJDProjection)__Pyx_PyInt_As_PEPJDProjection(__pyx_v_proj)); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 1750, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1751
 *         """
 *         cdef SlepcPEPJDProjection val = proj
 *         CHKERR( PEPJDSetProjection(self.pep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getJDProjection(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPJDSetProjection(__pyx_v_self->pep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1751, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1741
 *         return toInt(ival)
 * 
 *     def setJDProjection(self, proj):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the type of projection to be used in the Jacobi-Davidson solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setJDProjection", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1753
 *         CHKERR( PEPJDSetProjection(self.pep, val) )
 * 
 *     def getJDProjection(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the type of projection to be used in the Jacobi-Davidson solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_195getJDProjection(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_194getJDProjection[] = "PEP.getJDProjection(self)\n\n        Gets the type of projection to be used in the Jacobi-Davidson solver.\n\n        Returns\n        -------\n        proj: `PEP.JDProjection` enumerate\n               The type of projection.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_195getJDProjection(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getJDProjection (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getJDProjection", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getJDProjection", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_194getJDProjection(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_194getJDProjection(struct PySlepcPEPObject *__pyx_v_self) {
  PEPJDProjection __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getJDProjection", 0);

  /* "SLEPc/PEP.pyx":1762
 *                The type of projection.
 *         """
 *         cdef SlepcPEPJDProjection val = PEP_JD_PROJECTION_HARMONIC             # <<<<<<<<<<<<<<
 *         CHKERR( PEPJDGetProjection(self.pep, &val) )
 *         return val
 */
  __pyx_v_val = PEP_JD_PROJECTION_HARMONIC;

  /* "SLEPc/PEP.pyx":1763
 *         """
 *         cdef SlepcPEPJDProjection val = PEP_JD_PROJECTION_HARMONIC
 *         CHKERR( PEPJDGetProjection(self.pep, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPJDGetProjection(__pyx_v_self->pep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1763, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1764
 *         cdef SlepcPEPJDProjection val = PEP_JD_PROJECTION_HARMONIC
 *         CHKERR( PEPJDGetProjection(self.pep, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_PEPJDProjection(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1764, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1753
 *         CHKERR( PEPJDSetProjection(self.pep, val) )
 * 
 *     def getJDProjection(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the type of projection to be used in the Jacobi-Davidson solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getJDProjection", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1768
 *     #
 * 
 *     def setCISSExtraction(self, extraction):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the extraction technique used in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_197setCISSExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_196setCISSExtraction[] = "PEP.setCISSExtraction(self, extraction)\n\n        Sets the extraction technique used in the CISS solver.\n\n        Parameters\n        ----------\n        extraction: `PEP.CISSExtraction` enumerate\n               The extraction technique.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_197setCISSExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_extraction = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCISSExtraction (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_extraction,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_extraction)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCISSExtraction") < 0)) __PYX_ERR(19, 1768, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_extraction = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCISSExtraction", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1768, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setCISSExtraction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_196setCISSExtraction(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_extraction);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_196setCISSExtraction(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_extraction) {
  PEPCISSExtraction __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PEPCISSExtraction __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCISSExtraction", 0);

  /* "SLEPc/PEP.pyx":1777
 *                The extraction technique.
 *         """
 *         cdef SlepcPEPCISSExtraction val = extraction             # <<<<<<<<<<<<<<
 *         CHKERR( PEPCISSSetExtraction(self.pep, val) )
 * 
 */
  __pyx_t_1 = ((PEPCISSExtraction)__Pyx_PyInt_As_PEPCISSExtraction(__pyx_v_extraction)); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 1777, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1778
 *         """
 *         cdef SlepcPEPCISSExtraction val = extraction
 *         CHKERR( PEPCISSSetExtraction(self.pep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getCISSExtraction(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPCISSSetExtraction(__pyx_v_self->pep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(19, 1778, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1768
 *     #
 * 
 *     def setCISSExtraction(self, extraction):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the extraction technique used in the CISS solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setCISSExtraction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1780
 *         CHKERR( PEPCISSSetExtraction(self.pep, val) )
 * 
 *     def getCISSExtraction(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the extraction technique used in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_199getCISSExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_198getCISSExtraction[] = "PEP.getCISSExtraction(self)\n\n        Gets the extraction technique used in the CISS solver.\n\n        Returns\n        -------\n        extraction: `PEP.CISSExtraction` enumerate\n               The extraction technique.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_199getCISSExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSExtraction (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSExtraction", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSExtraction", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_198getCISSExtraction(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_198getCISSExtraction(struct PySlepcPEPObject *__pyx_v_self) {
  PEPCISSExtraction __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSExtraction", 0);

  /* "SLEPc/PEP.pyx":1789
 *                The extraction technique.
 *         """
 *         cdef SlepcPEPCISSExtraction val = PEP_CISS_EXTRACTION_RITZ             # <<<<<<<<<<<<<<
 *         CHKERR( PEPCISSGetExtraction(self.pep, &val) )
 *         return val
 */
  __pyx_v_val = PEP_CISS_EXTRACTION_RITZ;

  /* "SLEPc/PEP.pyx":1790
 *         """
 *         cdef SlepcPEPCISSExtraction val = PEP_CISS_EXTRACTION_RITZ
 *         CHKERR( PEPCISSGetExtraction(self.pep, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPCISSGetExtraction(__pyx_v_self->pep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1790, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1791
 *         cdef SlepcPEPCISSExtraction val = PEP_CISS_EXTRACTION_RITZ
 *         CHKERR( PEPCISSGetExtraction(self.pep, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setCISSSizes(self, ip=None, bs=None, ms=None, npart=None, bsmax=None, realmats=False):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_PEPCISSExtraction(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1791, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1780
 *         CHKERR( PEPCISSSetExtraction(self.pep, val) )
 * 
 *     def getCISSExtraction(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the extraction technique used in the CISS solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getCISSExtraction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1793
 *         return val
 * 
 *     def setCISSSizes(self, ip=None, bs=None, ms=None, npart=None, bsmax=None, realmats=False):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various size parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_201setCISSSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_200setCISSSizes[] = "PEP.setCISSSizes(self, ip=None, bs=None, ms=None, npart=None, bsmax=None, realmats=False)\n\n        Sets the values of various size parameters in the CISS solver.\n\n        Parameters\n        ----------\n        ip: int, optional\n             Number of integration points.\n        bs: int, optional\n             Block size.\n        ms: int, optional\n             Moment size.\n        npart: int, optional\n             Number of partitions when splitting the communicator.\n        bsmax: int, optional\n             Maximum block size.\n        realmats: bool, optional\n             True if A and B are real.\n\n        Notes\n        -----\n        The default number of partitions is 1. This means the internal `KSP` object\n        is shared among all processes of the `PEP` communicator. Otherwise, the\n        communicator is split into npart communicators, so that `npart` `KSP` solves\n        proceed simultaneously.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_201setCISSSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_ip = 0;
  PyObject *__pyx_v_bs = 0;
  PyObject *__pyx_v_ms = 0;
  PyObject *__pyx_v_npart = 0;
  PyObject *__pyx_v_bsmax = 0;
  PyObject *__pyx_v_realmats = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCISSSizes (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ip,&__pyx_n_s_bs,&__pyx_n_s_ms,&__pyx_n_s_npart,&__pyx_n_s_bsmax,&__pyx_n_s_realmats,0};
    PyObject* values[6] = {0,0,0,0,0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    values[3] = ((PyObject *)Py_None);
    values[4] = ((PyObject *)Py_None);
    values[5] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ip);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bs);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ms);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_npart);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bsmax);
          if (value) { values[4] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_realmats);
          if (value) { values[5] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCISSSizes") < 0)) __PYX_ERR(19, 1793, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_ip = values[0];
    __pyx_v_bs = values[1];
    __pyx_v_ms = values[2];
    __pyx_v_npart = values[3];
    __pyx_v_bsmax = values[4];
    __pyx_v_realmats = values[5];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCISSSizes", 0, 0, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1793, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setCISSSizes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_200setCISSSizes(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_ip, __pyx_v_bs, __pyx_v_ms, __pyx_v_npart, __pyx_v_bsmax, __pyx_v_realmats);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_200setCISSSizes(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_ip, PyObject *__pyx_v_bs, PyObject *__pyx_v_ms, PyObject *__pyx_v_npart, PyObject *__pyx_v_bsmax, PyObject *__pyx_v_realmats) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PetscInt __pyx_v_ival4;
  PetscInt __pyx_v_ival5;
  PetscBool __pyx_v_bval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PetscInt __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCISSSizes", 0);

  /* "SLEPc/PEP.pyx":1819
 *         proceed simultaneously.
 *         """
 *         cdef PetscInt  ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival2 = PETSC_DEFAULT
 *         cdef PetscInt  ival3 = PETSC_DEFAULT
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":1820
 *         """
 *         cdef PetscInt  ival1 = PETSC_DEFAULT
 *         cdef PetscInt  ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival3 = PETSC_DEFAULT
 *         cdef PetscInt  ival4 = PETSC_DEFAULT
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":1821
 *         cdef PetscInt  ival1 = PETSC_DEFAULT
 *         cdef PetscInt  ival2 = PETSC_DEFAULT
 *         cdef PetscInt  ival3 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival4 = PETSC_DEFAULT
 *         cdef PetscInt  ival5 = PETSC_DEFAULT
 */
  __pyx_v_ival3 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":1822
 *         cdef PetscInt  ival2 = PETSC_DEFAULT
 *         cdef PetscInt  ival3 = PETSC_DEFAULT
 *         cdef PetscInt  ival4 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival5 = PETSC_DEFAULT
 *         cdef PetscBool bval  = asBool(realmats)
 */
  __pyx_v_ival4 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":1823
 *         cdef PetscInt  ival3 = PETSC_DEFAULT
 *         cdef PetscInt  ival4 = PETSC_DEFAULT
 *         cdef PetscInt  ival5 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscBool bval  = asBool(realmats)
 *         if ip    is not None: ival1 = asInt(ip)
 */
  __pyx_v_ival5 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":1824
 *         cdef PetscInt  ival4 = PETSC_DEFAULT
 *         cdef PetscInt  ival5 = PETSC_DEFAULT
 *         cdef PetscBool bval  = asBool(realmats)             # <<<<<<<<<<<<<<
 *         if ip    is not None: ival1 = asInt(ip)
 *         if bs    is not None: ival2 = asInt(bs)
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_realmats); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(19, 1824, __pyx_L1_error)
  __pyx_v_bval = __pyx_t_1;

  /* "SLEPc/PEP.pyx":1825
 *         cdef PetscInt  ival5 = PETSC_DEFAULT
 *         cdef PetscBool bval  = asBool(realmats)
 *         if ip    is not None: ival1 = asInt(ip)             # <<<<<<<<<<<<<<
 *         if bs    is not None: ival2 = asInt(bs)
 *         if ms    is not None: ival3 = asInt(ms)
 */
  __pyx_t_2 = (__pyx_v_ip != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_ip); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 1825, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_4;
  }

  /* "SLEPc/PEP.pyx":1826
 *         cdef PetscBool bval  = asBool(realmats)
 *         if ip    is not None: ival1 = asInt(ip)
 *         if bs    is not None: ival2 = asInt(bs)             # <<<<<<<<<<<<<<
 *         if ms    is not None: ival3 = asInt(ms)
 *         if npart is not None: ival4 = asInt(npart)
 */
  __pyx_t_3 = (__pyx_v_bs != Py_None);
  __pyx_t_2 = (__pyx_t_3 != 0);
  if (__pyx_t_2) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_bs); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 1826, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_4;
  }

  /* "SLEPc/PEP.pyx":1827
 *         if ip    is not None: ival1 = asInt(ip)
 *         if bs    is not None: ival2 = asInt(bs)
 *         if ms    is not None: ival3 = asInt(ms)             # <<<<<<<<<<<<<<
 *         if npart is not None: ival4 = asInt(npart)
 *         if bsmax is not None: ival5 = asInt(bsmax)
 */
  __pyx_t_2 = (__pyx_v_ms != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_ms); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 1827, __pyx_L1_error)
    __pyx_v_ival3 = __pyx_t_4;
  }

  /* "SLEPc/PEP.pyx":1828
 *         if bs    is not None: ival2 = asInt(bs)
 *         if ms    is not None: ival3 = asInt(ms)
 *         if npart is not None: ival4 = asInt(npart)             # <<<<<<<<<<<<<<
 *         if bsmax is not None: ival5 = asInt(bsmax)
 *         CHKERR( PEPCISSSetSizes(self.pep, ival1, ival2, ival3, ival4, ival5, bval) )
 */
  __pyx_t_3 = (__pyx_v_npart != Py_None);
  __pyx_t_2 = (__pyx_t_3 != 0);
  if (__pyx_t_2) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_npart); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 1828, __pyx_L1_error)
    __pyx_v_ival4 = __pyx_t_4;
  }

  /* "SLEPc/PEP.pyx":1829
 *         if ms    is not None: ival3 = asInt(ms)
 *         if npart is not None: ival4 = asInt(npart)
 *         if bsmax is not None: ival5 = asInt(bsmax)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPCISSSetSizes(self.pep, ival1, ival2, ival3, ival4, ival5, bval) )
 * 
 */
  __pyx_t_2 = (__pyx_v_bsmax != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_bsmax); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 1829, __pyx_L1_error)
    __pyx_v_ival5 = __pyx_t_4;
  }

  /* "SLEPc/PEP.pyx":1830
 *         if npart is not None: ival4 = asInt(npart)
 *         if bsmax is not None: ival5 = asInt(bsmax)
 *         CHKERR( PEPCISSSetSizes(self.pep, ival1, ival2, ival3, ival4, ival5, bval) )             # <<<<<<<<<<<<<<
 * 
 *     def getCISSSizes(self):
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPCISSSetSizes(__pyx_v_self->pep, __pyx_v_ival1, __pyx_v_ival2, __pyx_v_ival3, __pyx_v_ival4, __pyx_v_ival5, __pyx_v_bval)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(19, 1830, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1793
 *         return val
 * 
 *     def setCISSSizes(self, ip=None, bs=None, ms=None, npart=None, bsmax=None, realmats=False):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various size parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setCISSSizes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1832
 *         CHKERR( PEPCISSSetSizes(self.pep, ival1, ival2, ival3, ival4, ival5, bval) )
 * 
 *     def getCISSSizes(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various size parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_203getCISSSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_202getCISSSizes[] = "PEP.getCISSSizes(self)\n\n        Gets the values of various size parameters in the CISS solver.\n\n        Returns\n        -------\n        ip: int\n             Number of integration points.\n        bs: int\n             Block size.\n        ms: int\n             Moment size.\n        npart: int\n             Number of partitions when splitting the communicator.\n        bsmax: int\n             Maximum block size.\n        realmats: bool\n             True if A and B are real.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_203getCISSSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSSizes (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSSizes", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSSizes", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_202getCISSSizes(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_202getCISSSizes(struct PySlepcPEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PetscInt __pyx_v_ival4;
  PetscInt __pyx_v_ival5;
  PetscBool __pyx_v_bval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSSizes", 0);

  /* "SLEPc/PEP.pyx":1851
 *              True if A and B are real.
 *         """
 *         cdef PetscInt  ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival2 = 0
 *         cdef PetscInt  ival3 = 0
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/PEP.pyx":1852
 *         """
 *         cdef PetscInt  ival1 = 0
 *         cdef PetscInt  ival2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival3 = 0
 *         cdef PetscInt  ival4 = 0
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/PEP.pyx":1853
 *         cdef PetscInt  ival1 = 0
 *         cdef PetscInt  ival2 = 0
 *         cdef PetscInt  ival3 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival4 = 0
 *         cdef PetscInt  ival5 = 0
 */
  __pyx_v_ival3 = 0;

  /* "SLEPc/PEP.pyx":1854
 *         cdef PetscInt  ival2 = 0
 *         cdef PetscInt  ival3 = 0
 *         cdef PetscInt  ival4 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival5 = 0
 *         cdef PetscBool bval  = PETSC_FALSE
 */
  __pyx_v_ival4 = 0;

  /* "SLEPc/PEP.pyx":1855
 *         cdef PetscInt  ival3 = 0
 *         cdef PetscInt  ival4 = 0
 *         cdef PetscInt  ival5 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscBool bval  = PETSC_FALSE
 *         CHKERR( PEPCISSGetSizes(self.pep, &ival1, &ival2, &ival3, &ival4, &ival5, &bval) )
 */
  __pyx_v_ival5 = 0;

  /* "SLEPc/PEP.pyx":1856
 *         cdef PetscInt  ival4 = 0
 *         cdef PetscInt  ival5 = 0
 *         cdef PetscBool bval  = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( PEPCISSGetSizes(self.pep, &ival1, &ival2, &ival3, &ival4, &ival5, &bval) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))
 */
  __pyx_v_bval = PETSC_FALSE;

  /* "SLEPc/PEP.pyx":1857
 *         cdef PetscInt  ival5 = 0
 *         cdef PetscBool bval  = PETSC_FALSE
 *         CHKERR( PEPCISSGetSizes(self.pep, &ival1, &ival2, &ival3, &ival4, &ival5, &bval) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPCISSGetSizes(__pyx_v_self->pep, (&__pyx_v_ival1), (&__pyx_v_ival2), (&__pyx_v_ival3), (&__pyx_v_ival4), (&__pyx_v_ival5), (&__pyx_v_bval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1857, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1858
 *         cdef PetscBool bval  = PETSC_FALSE
 *         CHKERR( PEPCISSGetSizes(self.pep, &ival1, &ival2, &ival3, &ival4, &ival5, &bval) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))             # <<<<<<<<<<<<<<
 * 
 *     def setCISSThreshold(self, delta=None, spur=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1858, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 1858, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival3); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 1858, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival4); if (unlikely(!__pyx_t_5)) __PYX_ERR(19, 1858, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival5); if (unlikely(!__pyx_t_6)) __PYX_ERR(19, 1858, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_bval); if (unlikely(!__pyx_t_7)) __PYX_ERR(19, 1858, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = PyTuple_New(6); if (unlikely(!__pyx_t_8)) __PYX_ERR(19, 1858, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_7);
  PyTuple_SET_ITEM(__pyx_t_8, 5, __pyx_t_7);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_t_6 = 0;
  __pyx_t_7 = 0;
  __pyx_r = __pyx_t_8;
  __pyx_t_8 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1832
 *         CHKERR( PEPCISSSetSizes(self.pep, ival1, ival2, ival3, ival4, ival5, bval) )
 * 
 *     def getCISSSizes(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various size parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getCISSSizes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1860
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))
 * 
 *     def setCISSThreshold(self, delta=None, spur=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various threshold parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_205setCISSThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_204setCISSThreshold[] = "PEP.setCISSThreshold(self, delta=None, spur=None)\n\n        Sets the values of various threshold parameters in the CISS solver.\n\n        Parameters\n        ----------\n        delta: float\n                Threshold for numerical rank.\n        spur: float\n                Spurious threshold (to discard spurious eigenpairs).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_205setCISSThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_delta = 0;
  PyObject *__pyx_v_spur = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCISSThreshold (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_delta,&__pyx_n_s_spur,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_spur);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCISSThreshold") < 0)) __PYX_ERR(19, 1860, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_delta = values[0];
    __pyx_v_spur = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCISSThreshold", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1860, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setCISSThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_204setCISSThreshold(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_delta, __pyx_v_spur);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_204setCISSThreshold(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_delta, PyObject *__pyx_v_spur) {
  PetscReal __pyx_v_rval1;
  PetscReal __pyx_v_rval2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscReal __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCISSThreshold", 0);

  /* "SLEPc/PEP.pyx":1871
 *                 Spurious threshold (to discard spurious eigenpairs).
 *         """
 *         cdef PetscReal rval1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval2 = PETSC_DEFAULT
 *         if delta is not None: rval1 = asReal(delta)
 */
  __pyx_v_rval1 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":1872
 *         """
 *         cdef PetscReal rval1 = PETSC_DEFAULT
 *         cdef PetscReal rval2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if delta is not None: rval1 = asReal(delta)
 *         if spur  is not None: rval2 = asReal(spur)
 */
  __pyx_v_rval2 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":1873
 *         cdef PetscReal rval1 = PETSC_DEFAULT
 *         cdef PetscReal rval2 = PETSC_DEFAULT
 *         if delta is not None: rval1 = asReal(delta)             # <<<<<<<<<<<<<<
 *         if spur  is not None: rval2 = asReal(spur)
 *         CHKERR( PEPCISSSetThreshold(self.pep, rval1, rval2) )
 */
  __pyx_t_1 = (__pyx_v_delta != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_delta); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 1873, __pyx_L1_error)
    __pyx_v_rval1 = __pyx_t_3;
  }

  /* "SLEPc/PEP.pyx":1874
 *         cdef PetscReal rval2 = PETSC_DEFAULT
 *         if delta is not None: rval1 = asReal(delta)
 *         if spur  is not None: rval2 = asReal(spur)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPCISSSetThreshold(self.pep, rval1, rval2) )
 * 
 */
  __pyx_t_2 = (__pyx_v_spur != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_spur); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(19, 1874, __pyx_L1_error)
    __pyx_v_rval2 = __pyx_t_3;
  }

  /* "SLEPc/PEP.pyx":1875
 *         if delta is not None: rval1 = asReal(delta)
 *         if spur  is not None: rval2 = asReal(spur)
 *         CHKERR( PEPCISSSetThreshold(self.pep, rval1, rval2) )             # <<<<<<<<<<<<<<
 * 
 *     def getCISSThreshold(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPCISSSetThreshold(__pyx_v_self->pep, __pyx_v_rval1, __pyx_v_rval2)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(19, 1875, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1860
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))
 * 
 *     def setCISSThreshold(self, delta=None, spur=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various threshold parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setCISSThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1877
 *         CHKERR( PEPCISSSetThreshold(self.pep, rval1, rval2) )
 * 
 *     def getCISSThreshold(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various threshold parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_207getCISSThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_206getCISSThreshold[] = "PEP.getCISSThreshold(self)\n\n        Gets the values of various threshold parameters in the CISS solver.\n\n        Returns\n        -------\n        delta: float\n                Threshold for numerical rank.\n        spur: float\n                Spurious threshold (to discard spurious eigenpairs.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_207getCISSThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSThreshold (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSThreshold", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSThreshold", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_206getCISSThreshold(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_206getCISSThreshold(struct PySlepcPEPObject *__pyx_v_self) {
  PetscReal __pyx_v_delta;
  PetscReal __pyx_v_spur;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSThreshold", 0);

  /* "SLEPc/PEP.pyx":1888
 *                 Spurious threshold (to discard spurious eigenpairs.
 *         """
 *         cdef PetscReal delta = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal spur  = 0
 *         CHKERR( PEPCISSGetThreshold(self.pep, &delta, &spur) )
 */
  __pyx_v_delta = 0.0;

  /* "SLEPc/PEP.pyx":1889
 *         """
 *         cdef PetscReal delta = 0
 *         cdef PetscReal spur  = 0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPCISSGetThreshold(self.pep, &delta, &spur) )
 *         return (toReal(delta), toReal(spur))
 */
  __pyx_v_spur = 0.0;

  /* "SLEPc/PEP.pyx":1890
 *         cdef PetscReal delta = 0
 *         cdef PetscReal spur  = 0
 *         CHKERR( PEPCISSGetThreshold(self.pep, &delta, &spur) )             # <<<<<<<<<<<<<<
 *         return (toReal(delta), toReal(spur))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPCISSGetThreshold(__pyx_v_self->pep, (&__pyx_v_delta), (&__pyx_v_spur))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1890, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1891
 *         cdef PetscReal spur  = 0
 *         CHKERR( PEPCISSGetThreshold(self.pep, &delta, &spur) )
 *         return (toReal(delta), toReal(spur))             # <<<<<<<<<<<<<<
 * 
 *     def setCISSRefinement(self, inner=None, blsize=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_delta); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_spur); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 1891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 1891, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1877
 *         CHKERR( PEPCISSSetThreshold(self.pep, rval1, rval2) )
 * 
 *     def getCISSThreshold(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various threshold parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getCISSThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1893
 *         return (toReal(delta), toReal(spur))
 * 
 *     def setCISSRefinement(self, inner=None, blsize=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various refinement parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_209setCISSRefinement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_208setCISSRefinement[] = "PEP.setCISSRefinement(self, inner=None, blsize=None)\n\n        Sets the values of various refinement parameters in the CISS solver.\n\n        Parameters\n        ----------\n        inner: int, optional\n             Number of iterative refinement iterations (inner loop).\n        blsize: int, optional\n             Number of iterative refinement iterations (blocksize loop).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_209setCISSRefinement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_inner = 0;
  PyObject *__pyx_v_blsize = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCISSRefinement (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inner,&__pyx_n_s_blsize,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_inner);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_blsize);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCISSRefinement") < 0)) __PYX_ERR(19, 1893, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_inner = values[0];
    __pyx_v_blsize = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCISSRefinement", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(19, 1893, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setCISSRefinement", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_208setCISSRefinement(((struct PySlepcPEPObject *)__pyx_v_self), __pyx_v_inner, __pyx_v_blsize);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_208setCISSRefinement(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_inner, PyObject *__pyx_v_blsize) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCISSRefinement", 0);

  /* "SLEPc/PEP.pyx":1904
 *              Number of iterative refinement iterations (blocksize loop).
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if inner  is not None: ival1 = asInt(inner)
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":1905
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if inner  is not None: ival1 = asInt(inner)
 *         if blsize is not None: ival2 = asInt(blsize)
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/PEP.pyx":1906
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if inner  is not None: ival1 = asInt(inner)             # <<<<<<<<<<<<<<
 *         if blsize is not None: ival2 = asInt(blsize)
 *         CHKERR( PEPCISSSetRefinement(self.pep, ival1, ival2) )
 */
  __pyx_t_1 = (__pyx_v_inner != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_inner); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 1906, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_3;
  }

  /* "SLEPc/PEP.pyx":1907
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if inner  is not None: ival1 = asInt(inner)
 *         if blsize is not None: ival2 = asInt(blsize)             # <<<<<<<<<<<<<<
 *         CHKERR( PEPCISSSetRefinement(self.pep, ival1, ival2) )
 * 
 */
  __pyx_t_2 = (__pyx_v_blsize != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_blsize); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(19, 1907, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_3;
  }

  /* "SLEPc/PEP.pyx":1908
 *         if inner  is not None: ival1 = asInt(inner)
 *         if blsize is not None: ival2 = asInt(blsize)
 *         CHKERR( PEPCISSSetRefinement(self.pep, ival1, ival2) )             # <<<<<<<<<<<<<<
 * 
 *     def getCISSRefinement(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPCISSSetRefinement(__pyx_v_self->pep, __pyx_v_ival1, __pyx_v_ival2)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(19, 1908, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1893
 *         return (toReal(delta), toReal(spur))
 * 
 *     def setCISSRefinement(self, inner=None, blsize=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various refinement parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.setCISSRefinement", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1910
 *         CHKERR( PEPCISSSetRefinement(self.pep, ival1, ival2) )
 * 
 *     def getCISSRefinement(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various refinement parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_211getCISSRefinement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_210getCISSRefinement[] = "PEP.getCISSRefinement(self)\n\n        Gets the values of various refinement parameters in the CISS solver.\n\n        Returns\n        -------\n        inner: int\n             Number of iterative refinement iterations (inner loop).\n        blsize: int\n             Number of iterative refinement iterations (blocksize loop).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_211getCISSRefinement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSRefinement (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSRefinement", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSRefinement", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_210getCISSRefinement(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_210getCISSRefinement(struct PySlepcPEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSRefinement", 0);

  /* "SLEPc/PEP.pyx":1921
 *              Number of iterative refinement iterations (blocksize loop).
 *         """
 *         cdef PetscInt ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         CHKERR( PEPCISSGetRefinement(self.pep, &ival1, &ival2) )
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/PEP.pyx":1922
 *         """
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( PEPCISSGetRefinement(self.pep, &ival1, &ival2) )
 *         return (toInt(ival1), toInt(ival2))
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/PEP.pyx":1923
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0
 *         CHKERR( PEPCISSGetRefinement(self.pep, &ival1, &ival2) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPCISSGetRefinement(__pyx_v_self->pep, (&__pyx_v_ival1), (&__pyx_v_ival2))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1923, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1924
 *         cdef PetscInt ival2 = 0
 *         CHKERR( PEPCISSGetRefinement(self.pep, &ival1, &ival2) )
 *         return (toInt(ival1), toInt(ival2))             # <<<<<<<<<<<<<<
 * 
 *     def getCISSKSPs(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1924, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 1924, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 1924, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1910
 *         CHKERR( PEPCISSSetRefinement(self.pep, ival1, ival2) )
 * 
 *     def getCISSRefinement(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various refinement parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getCISSRefinement", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1926
 *         return (toInt(ival1), toInt(ival2))
 * 
 *     def getCISSKSPs(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the array of linear solver objects associated with
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_213getCISSKSPs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3PEP_212getCISSKSPs[] = "PEP.getCISSKSPs(self)\n\n        Retrieve the array of linear solver objects associated with\n        the CISS solver.\n\n        Returns\n        -------\n        ksp: list of `KSP`\n             The linear solver objects.\n\n        Notes\n        -----\n        The number of `KSP` solvers is equal to the number of integration\n        points divided by the number of partitions. This value is halved in\n        the case of real matrices with a region centered at the real axis.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_213getCISSKSPs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSKSPs (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSKSPs", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSKSPs", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_212getCISSKSPs(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_212getCISSKSPs(struct PySlepcPEPObject *__pyx_v_self) {
  CYTHON_UNUSED PetscInt __pyx_v_i;
  PetscInt __pyx_v_n;
  KSP *__pyx_v_p;
  PetscInt __pyx_9genexpr14__pyx_v_i;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PetscInt __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSKSPs", 0);

  /* "SLEPc/PEP.pyx":1942
 *         the case of real matrices with a region centered at the real axis.
 *         """
 *         cdef PetscInt i = 0, n = 0             # <<<<<<<<<<<<<<
 *         cdef PetscKSP *p = NULL
 *         CHKERR( PEPCISSGetKSPs(self.pep, &n, &p) )
 */
  __pyx_v_i = 0;
  __pyx_v_n = 0;

  /* "SLEPc/PEP.pyx":1943
 *         """
 *         cdef PetscInt i = 0, n = 0
 *         cdef PetscKSP *p = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( PEPCISSGetKSPs(self.pep, &n, &p) )
 *         return [ref_KSP(p[i]) for i from 0 <= i <n]
 */
  __pyx_v_p = NULL;

  /* "SLEPc/PEP.pyx":1944
 *         cdef PetscInt i = 0, n = 0
 *         cdef PetscKSP *p = NULL
 *         CHKERR( PEPCISSGetKSPs(self.pep, &n, &p) )             # <<<<<<<<<<<<<<
 *         return [ref_KSP(p[i]) for i from 0 <= i <n]
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PEPCISSGetKSPs(__pyx_v_self->pep, (&__pyx_v_n), (&__pyx_v_p))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(19, 1944, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":1945
 *         cdef PetscKSP *p = NULL
 *         CHKERR( PEPCISSGetKSPs(self.pep, &n, &p) )
 *         return [ref_KSP(p[i]) for i from 0 <= i <n]             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  { /* enter inner scope */
    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1945, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __pyx_v_n;
    for (__pyx_9genexpr14__pyx_v_i = 0; __pyx_9genexpr14__pyx_v_i < __pyx_t_3; __pyx_9genexpr14__pyx_v_i++) {
      __pyx_t_4 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_KSP((__pyx_v_p[__pyx_9genexpr14__pyx_v_i]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 1945, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_4))) __PYX_ERR(19, 1945, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  } /* exit inner scope */
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1926
 *         return (toInt(ival1), toInt(ival2))
 * 
 *     def getCISSKSPs(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the array of linear solver objects associated with
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.getCISSKSPs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1950
 * 
 *     property problem_type:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getProblemType()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_12problem_type_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_12problem_type_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_12problem_type___get__(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_12problem_type___get__(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/PEP.pyx":1951
 *     property problem_type:
 *         def __get__(self):
 *             return self.getProblemType()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setProblemType(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getProblemType); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1951, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1951, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1950
 * 
 *     property problem_type:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getProblemType()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.problem_type.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1952
 *         def __get__(self):
 *             return self.getProblemType()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setProblemType(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_12problem_type_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_12problem_type_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_12problem_type_2__set__(((struct PySlepcPEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3PEP_12problem_type_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/PEP.pyx":1953
 *             return self.getProblemType()
 *         def __set__(self, value):
 *             self.setProblemType(value)             # <<<<<<<<<<<<<<
 * 
 *     property which:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setProblemType); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1953, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1953, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":1952
 *         def __get__(self):
 *             return self.getProblemType()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setProblemType(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.problem_type.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1956
 * 
 *     property which:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_5which_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_5which_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_5which___get__(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_5which___get__(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/PEP.pyx":1957
 *     property which:
 *         def __get__(self):
 *             return self.getWhichEigenpairs()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setWhichEigenpairs(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getWhichEigenpairs); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1957, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1957, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1956
 * 
 *     property which:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.which.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1958
 *         def __get__(self):
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setWhichEigenpairs(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_5which_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_5which_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_5which_2__set__(((struct PySlepcPEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3PEP_5which_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/PEP.pyx":1959
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):
 *             self.setWhichEigenpairs(value)             # <<<<<<<<<<<<<<
 * 
 *     property target:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setWhichEigenpairs); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1959, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1959, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":1958
 *         def __get__(self):
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setWhichEigenpairs(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.which.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1962
 * 
 *     property target:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTarget()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_6target_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_6target_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_6target___get__(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_6target___get__(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/PEP.pyx":1963
 *     property target:
 *         def __get__(self):
 *             return self.getTarget()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTarget(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTarget); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1963, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1963, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1962
 * 
 *     property target:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTarget()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.target.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1964
 *         def __get__(self):
 *             return self.getTarget()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTarget(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_6target_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_6target_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_6target_2__set__(((struct PySlepcPEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3PEP_6target_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/PEP.pyx":1965
 *             return self.getTarget()
 *         def __set__(self, value):
 *             self.setTarget(value)             # <<<<<<<<<<<<<<
 * 
 *     property extract:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTarget); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1965, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1965, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":1964
 *         def __get__(self):
 *             return self.getTarget()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTarget(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.target.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1968
 * 
 *     property extract:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getExtract()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_7extract_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_7extract_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_7extract___get__(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_7extract___get__(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/PEP.pyx":1969
 *     property extract:
 *         def __get__(self):
 *             return self.getExtract()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setExtract(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getExtract); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1969, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1969, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1968
 * 
 *     property extract:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getExtract()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.extract.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1970
 *         def __get__(self):
 *             return self.getExtract()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setExtract(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_7extract_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_7extract_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_7extract_2__set__(((struct PySlepcPEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3PEP_7extract_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/PEP.pyx":1971
 *             return self.getExtract()
 *         def __set__(self, value):
 *             self.setExtract(value)             # <<<<<<<<<<<<<<
 * 
 *     property tol:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setExtract); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1971, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1971, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":1970
 *         def __get__(self):
 *             return self.getExtract()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setExtract(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.extract.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1974
 * 
 *     property tol:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_3tol_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_3tol_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_3tol___get__(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_3tol___get__(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/PEP.pyx":1975
 *     property tol:
 *         def __get__(self):
 *             return self.getTolerances()[0]             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTolerances(tol=value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTolerances); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1975, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1975, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1975, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1974
 * 
 *     property tol:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.tol.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1976
 *         def __get__(self):
 *             return self.getTolerances()[0]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(tol=value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_3tol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_3tol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_3tol_2__set__(((struct PySlepcPEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3PEP_3tol_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/PEP.pyx":1977
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 *             self.setTolerances(tol=value)             # <<<<<<<<<<<<<<
 * 
 *     property max_it:
 */
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTolerances); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1977, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1977, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_tol, __pyx_v_value) < 0) __PYX_ERR(19, 1977, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 1977, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/PEP.pyx":1976
 *         def __get__(self):
 *             return self.getTolerances()[0]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(tol=value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.tol.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1980
 * 
 *     property max_it:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_6max_it_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_6max_it_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_6max_it___get__(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_6max_it___get__(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/PEP.pyx":1981
 *     property max_it:
 *         def __get__(self):
 *             return self.getTolerances()[1]             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTolerances(max_it=value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTolerances); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1981, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1981, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1981, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1980
 * 
 *     property max_it:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.max_it.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1982
 *         def __get__(self):
 *             return self.getTolerances()[1]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(max_it=value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_6max_it_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_6max_it_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_6max_it_2__set__(((struct PySlepcPEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3PEP_6max_it_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/PEP.pyx":1983
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 *             self.setTolerances(max_it=value)             # <<<<<<<<<<<<<<
 * 
 *     property track_all:
 */
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTolerances); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1983, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1983, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_it, __pyx_v_value) < 0) __PYX_ERR(19, 1983, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(19, 1983, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/PEP.pyx":1982
 *         def __get__(self):
 *             return self.getTolerances()[1]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(max_it=value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.max_it.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1986
 * 
 *     property track_all:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTrackAll()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_9track_all_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_9track_all_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_9track_all___get__(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_9track_all___get__(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/PEP.pyx":1987
 *     property track_all:
 *         def __get__(self):
 *             return self.getTrackAll()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTrackAll(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTrackAll); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1987, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1987, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1986
 * 
 *     property track_all:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTrackAll()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.track_all.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1988
 *         def __get__(self):
 *             return self.getTrackAll()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTrackAll(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_9track_all_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_9track_all_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_9track_all_2__set__(((struct PySlepcPEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3PEP_9track_all_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/PEP.pyx":1989
 *             return self.getTrackAll()
 *         def __set__(self, value):
 *             self.setTrackAll(value)             # <<<<<<<<<<<<<<
 * 
 *     property st:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTrackAll); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1989, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1989, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":1988
 *         def __get__(self):
 *             return self.getTrackAll()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTrackAll(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.track_all.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1992
 * 
 *     property st:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getST()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_2st_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_2st_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_2st___get__(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_2st___get__(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/PEP.pyx":1993
 *     property st:
 *         def __get__(self):
 *             return self.getST()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setST(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getST); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1993, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1993, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1992
 * 
 *     property st:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getST()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.st.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1994
 *         def __get__(self):
 *             return self.getST()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setST(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_2st_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_2st_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_2st_2__set__(((struct PySlepcPEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3PEP_2st_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/PEP.pyx":1995
 *             return self.getST()
 *         def __set__(self, value):
 *             self.setST(value)             # <<<<<<<<<<<<<<
 * 
 *     property bv:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setST); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1995, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1995, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":1994
 *         def __get__(self):
 *             return self.getST()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setST(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.st.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":1998
 * 
 *     property bv:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getBV()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_2bv_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_2bv_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_2bv___get__(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_2bv___get__(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/PEP.pyx":1999
 *     property bv:
 *         def __get__(self):
 *             return self.getBV()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setBV(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getBV); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 1999, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 1999, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":1998
 * 
 *     property bv:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getBV()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.bv.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":2000
 *         def __get__(self):
 *             return self.getBV()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setBV(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_2bv_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_2bv_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_2bv_2__set__(((struct PySlepcPEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3PEP_2bv_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/PEP.pyx":2001
 *             return self.getBV()
 *         def __set__(self, value):
 *             self.setBV(value)             # <<<<<<<<<<<<<<
 * 
 *     property rg:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setBV); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 2001, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 2001, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":2000
 *         def __get__(self):
 *             return self.getBV()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setBV(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.bv.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":2004
 * 
 *     property rg:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getRG()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_2rg_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_2rg_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_2rg___get__(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_2rg___get__(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/PEP.pyx":2005
 *     property rg:
 *         def __get__(self):
 *             return self.getRG()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setRG(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getRG); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 2005, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 2005, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":2004
 * 
 *     property rg:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getRG()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.rg.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":2006
 *         def __get__(self):
 *             return self.getRG()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setRG(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_2rg_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_2rg_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_2rg_2__set__(((struct PySlepcPEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3PEP_2rg_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/PEP.pyx":2007
 *             return self.getRG()
 *         def __set__(self, value):
 *             self.setRG(value)             # <<<<<<<<<<<<<<
 * 
 *     property ds:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setRG); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 2007, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 2007, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":2006
 *         def __get__(self):
 *             return self.getRG()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setRG(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.rg.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":2010
 * 
 *     property ds:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getDS()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_2ds_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3PEP_2ds_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_2ds___get__(((struct PySlepcPEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3PEP_2ds___get__(struct PySlepcPEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/PEP.pyx":2011
 *     property ds:
 *         def __get__(self):
 *             return self.getDS()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setDS(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getDS); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 2011, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 2011, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/PEP.pyx":2010
 * 
 *     property ds:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getDS()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.ds.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/PEP.pyx":2012
 *         def __get__(self):
 *             return self.getDS()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setDS(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_2ds_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3PEP_2ds_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3PEP_2ds_2__set__(((struct PySlepcPEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3PEP_2ds_2__set__(struct PySlepcPEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/PEP.pyx":2013
 *             return self.getDS()
 *         def __set__(self, value):
 *             self.setDS(value)             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setDS); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 2013, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 2013, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/PEP.pyx":2012
 *         def __get__(self):
 *             return self.getDS()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setDS(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.PEP.ds.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":174
 *     CISSExtraction  = NEPCISSExtraction
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.nep
 *         self.nep = NULL
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP___cinit__(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3NEP___cinit__(struct PySlepcNEPObject *__pyx_v_self) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "SLEPc/NEP.pyx":175
 * 
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.nep             # <<<<<<<<<<<<<<
 *         self.nep = NULL
 * 
 */
  __pyx_v_self->__pyx_base.obj = ((PetscObject *)(&__pyx_v_self->nep));

  /* "SLEPc/NEP.pyx":176
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.nep
 *         self.nep = NULL             # <<<<<<<<<<<<<<
 * 
 *     def view(self, Viewer viewer=None):
 */
  __pyx_v_self->nep = NULL;

  /* "SLEPc/NEP.pyx":174
 *     CISSExtraction  = NEPCISSExtraction
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.nep
 *         self.nep = NULL
 */

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":178
 *         self.nep = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the NEP data structure.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_2view[] = "NEP.view(self, Viewer viewer=None)\n\n        Prints the NEP data structure.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional.\n            Visualization context; if not provided, the standard\n            output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("view (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "view") < 0)) __PYX_ERR(20, 178, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("view", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 178, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(20, 178, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_2view(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_2view(struct PySlepcNEPObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("view", 0);

  /* "SLEPc/NEP.pyx":188
 *             output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPView(self.nep, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/NEP.pyx":189
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( NEPView(self.nep, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def destroy(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPView(__pyx_v_self->nep, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 189, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":178
 *         self.nep = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the NEP data structure.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":191
 *         CHKERR( NEPView(self.nep, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the NEP object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_4destroy[] = "NEP.destroy(self)\n\n        Destroys the NEP object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("destroy (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("destroy", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "destroy", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_4destroy(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_4destroy(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("destroy", 0);

  /* "SLEPc/NEP.pyx":195
 *         Destroys the NEP object.
 *         """
 *         CHKERR( NEPDestroy(&self.nep) )             # <<<<<<<<<<<<<<
 *         self.nep = NULL
 *         return self
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPDestroy((&__pyx_v_self->nep))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 195, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":196
 *         """
 *         CHKERR( NEPDestroy(&self.nep) )
 *         self.nep = NULL             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  __pyx_v_self->nep = NULL;

  /* "SLEPc/NEP.pyx":197
 *         CHKERR( NEPDestroy(&self.nep) )
 *         self.nep = NULL
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def reset(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":191
 *         CHKERR( NEPView(self.nep, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the NEP object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.destroy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":199
 *         return self
 * 
 *     def reset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Resets the NEP object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_7reset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_6reset[] = "NEP.reset(self)\n\n        Resets the NEP object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_7reset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("reset (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("reset", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "reset", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_6reset(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_6reset(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("reset", 0);

  /* "SLEPc/NEP.pyx":203
 *         Resets the NEP object.
 *         """
 *         CHKERR( NEPReset(self.nep) )             # <<<<<<<<<<<<<<
 * 
 *     def create(self, comm=None):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPReset(__pyx_v_self->nep)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 203, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":199
 *         return self
 * 
 *     def reset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Resets the NEP object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.reset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":205
 *         CHKERR( NEPReset(self.nep) )
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the NEP object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_9create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_8create[] = "NEP.create(self, comm=None)\n\n        Creates the NEP object.\n\n        Parameters\n        ----------\n        comm: Comm, optional.\n            MPI communicator. If not provided, it defaults to all\n            processes.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_9create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comm = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comm,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comm);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create") < 0)) __PYX_ERR(20, 205, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_comm = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("create", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 205, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_8create(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_comm);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_8create(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_comm) {
  MPI_Comm __pyx_v_ccomm;
  NEP __pyx_v_newnep;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  MPI_Comm __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("create", 0);

  /* "SLEPc/NEP.pyx":215
 *             processes.
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())             # <<<<<<<<<<<<<<
 *         cdef SlepcNEP newnep = NULL
 *         CHKERR( NEPCreate(ccomm, &newnep) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_def_Comm(__pyx_v_comm, __pyx_f_8slepc4py_5SLEPc_SLEPC_COMM_DEFAULT()); if (unlikely(PyErr_Occurred())) __PYX_ERR(20, 215, __pyx_L1_error)
  __pyx_v_ccomm = __pyx_t_1;

  /* "SLEPc/NEP.pyx":216
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcNEP newnep = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( NEPCreate(ccomm, &newnep) )
 *         SlepcCLEAR(self.obj); self.nep = newnep
 */
  __pyx_v_newnep = NULL;

  /* "SLEPc/NEP.pyx":217
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcNEP newnep = NULL
 *         CHKERR( NEPCreate(ccomm, &newnep) )             # <<<<<<<<<<<<<<
 *         SlepcCLEAR(self.obj); self.nep = newnep
 *         return self
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPCreate(__pyx_v_ccomm, (&__pyx_v_newnep))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 217, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":218
 *         cdef SlepcNEP newnep = NULL
 *         CHKERR( NEPCreate(ccomm, &newnep) )
 *         SlepcCLEAR(self.obj); self.nep = newnep             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_SlepcCLEAR(__pyx_v_self->__pyx_base.obj));
  __pyx_v_self->nep = __pyx_v_newnep;

  /* "SLEPc/NEP.pyx":219
 *         CHKERR( NEPCreate(ccomm, &newnep) )
 *         SlepcCLEAR(self.obj); self.nep = newnep
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def setType(self, nep_type):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":205
 *         CHKERR( NEPReset(self.nep) )
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the NEP object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":221
 *         return self
 * 
 *     def setType(self, nep_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the particular solver to be used in the NEP object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_11setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_10setType[] = "NEP.setType(self, nep_type)\n\n        Selects the particular solver to be used in the NEP object.\n\n        Parameters\n        ----------\n        nep_type: `NEP.Type` enumerate\n            The solver to be used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_11setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nep_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nep_type,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nep_type)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setType") < 0)) __PYX_ERR(20, 221, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_nep_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 221, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_10setType(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_nep_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_10setType(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_nep_type) {
  const char* __pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setType", 0);
  __Pyx_INCREF(__pyx_v_nep_type);

  /* "SLEPc/NEP.pyx":230
 *             The solver to be used.
 *         """
 *         cdef SlepcNEPType cval = NULL             # <<<<<<<<<<<<<<
 *         nep_type = str2bytes(nep_type, &cval)
 *         CHKERR( NEPSetType(self.nep, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/NEP.pyx":231
 *         """
 *         cdef SlepcNEPType cval = NULL
 *         nep_type = str2bytes(nep_type, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSetType(self.nep, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_nep_type, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 231, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_nep_type, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":232
 *         cdef SlepcNEPType cval = NULL
 *         nep_type = str2bytes(nep_type, &cval)
 *         CHKERR( NEPSetType(self.nep, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getType(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetType(__pyx_v_self->nep, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 232, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":221
 *         return self
 * 
 *     def setType(self, nep_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the particular solver to be used in the NEP object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_nep_type);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":234
 *         CHKERR( NEPSetType(self.nep, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the NEP type of this object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_13getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_12getType[] = "NEP.getType(self)\n\n        Gets the NEP type of this object.\n\n        Returns\n        -------\n        type: `NEP.Type` enumerate\n            The solver currently being used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_13getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_12getType(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_12getType(struct PySlepcNEPObject *__pyx_v_self) {
  const char* __pyx_v_nep_type;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getType", 0);

  /* "SLEPc/NEP.pyx":243
 *             The solver currently being used.
 *         """
 *         cdef SlepcNEPType nep_type = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetType(self.nep, &nep_type) )
 *         return bytes2str(nep_type)
 */
  __pyx_v_nep_type = NULL;

  /* "SLEPc/NEP.pyx":244
 *         """
 *         cdef SlepcNEPType nep_type = NULL
 *         CHKERR( NEPGetType(self.nep, &nep_type) )             # <<<<<<<<<<<<<<
 *         return bytes2str(nep_type)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetType(__pyx_v_self->nep, (&__pyx_v_nep_type))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 244, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":245
 *         cdef SlepcNEPType nep_type = NULL
 *         CHKERR( NEPGetType(self.nep, &nep_type) )
 *         return bytes2str(nep_type)             # <<<<<<<<<<<<<<
 * 
 *     def getOptionsPrefix(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_nep_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 245, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":234
 *         CHKERR( NEPSetType(self.nep, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the NEP type of this object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":247
 *         return bytes2str(nep_type)
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all NEP options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_15getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_14getOptionsPrefix[] = "NEP.getOptionsPrefix(self)\n\n        Gets the prefix used for searching for all NEP options in the\n        database.\n\n        Returns\n        -------\n        prefix: string\n            The prefix string set for this NEP object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_15getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOptionsPrefix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOptionsPrefix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOptionsPrefix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_14getOptionsPrefix(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_14getOptionsPrefix(struct PySlepcNEPObject *__pyx_v_self) {
  const char *__pyx_v_prefix;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOptionsPrefix", 0);

  /* "SLEPc/NEP.pyx":257
 *             The prefix string set for this NEP object.
 *         """
 *         cdef const_char *prefix = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetOptionsPrefix(self.nep, &prefix) )
 *         return bytes2str(prefix)
 */
  __pyx_v_prefix = NULL;

  /* "SLEPc/NEP.pyx":258
 *         """
 *         cdef const_char *prefix = NULL
 *         CHKERR( NEPGetOptionsPrefix(self.nep, &prefix) )             # <<<<<<<<<<<<<<
 *         return bytes2str(prefix)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetOptionsPrefix(__pyx_v_self->nep, (&__pyx_v_prefix))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 258, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":259
 *         cdef const_char *prefix = NULL
 *         CHKERR( NEPGetOptionsPrefix(self.nep, &prefix) )
 *         return bytes2str(prefix)             # <<<<<<<<<<<<<<
 * 
 *     def setOptionsPrefix(self, prefix):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_prefix); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 259, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":247
 *         return bytes2str(nep_type)
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all NEP options in the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":261
 *         return bytes2str(prefix)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all NEP options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_17setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_16setOptionsPrefix[] = "NEP.setOptionsPrefix(self, prefix)\n\n        Sets the prefix used for searching for all NEP options in the\n        database.\n\n        Parameters\n        ----------\n        prefix: string\n            The prefix string to prepend to all NEP option requests.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_17setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOptionsPrefix") < 0)) __PYX_ERR(20, 261, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 261, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_16setOptionsPrefix(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_16setOptionsPrefix(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/NEP.pyx":271
 *             The prefix string to prepend to all NEP option requests.
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( NEPSetOptionsPrefix(self.nep, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/NEP.pyx":272
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSetOptionsPrefix(self.nep, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 272, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":273
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( NEPSetOptionsPrefix(self.nep, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def appendOptionsPrefix(self, prefix):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetOptionsPrefix(__pyx_v_self->nep, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 273, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":261
 *         return bytes2str(prefix)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all NEP options in the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":275
 *         CHKERR( NEPSetOptionsPrefix(self.nep, cval) )
 * 
 *     def appendOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Appends to the prefix used for searching for all NEP options
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_19appendOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_18appendOptionsPrefix[] = "NEP.appendOptionsPrefix(self, prefix)\n\n        Appends to the prefix used for searching for all NEP options\n        in the database.\n\n        Parameters\n        ----------\n        prefix: string\n            The prefix string to prepend to all NEP option requests.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_19appendOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("appendOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "appendOptionsPrefix") < 0)) __PYX_ERR(20, 275, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("appendOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 275, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.appendOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_18appendOptionsPrefix(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_18appendOptionsPrefix(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("appendOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/NEP.pyx":285
 *             The prefix string to prepend to all NEP option requests.
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( NEPAppendOptionsPrefix(self.nep, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/NEP.pyx":286
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPAppendOptionsPrefix(self.nep, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 286, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":287
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( NEPAppendOptionsPrefix(self.nep, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def setFromOptions(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPAppendOptionsPrefix(__pyx_v_self->nep, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 287, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":275
 *         CHKERR( NEPSetOptionsPrefix(self.nep, cval) )
 * 
 *     def appendOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Appends to the prefix used for searching for all NEP options
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.appendOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":289
 *         CHKERR( NEPAppendOptionsPrefix(self.nep, cval) )
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets NEP options from the options database. This routine must
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_21setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_20setFromOptions[] = "NEP.setFromOptions(self)\n\n        Sets NEP options from the options database. This routine must\n        be called before `setUp()` if the user is to be allowed to set\n        the solver type.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_21setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFromOptions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setFromOptions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setFromOptions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_20setFromOptions(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_20setFromOptions(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFromOptions", 0);

  /* "SLEPc/NEP.pyx":295
 *         the solver type.
 *         """
 *         CHKERR( NEPSetFromOptions(self.nep) )             # <<<<<<<<<<<<<<
 * 
 *     def getProblemType(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetFromOptions(__pyx_v_self->nep)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 295, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":289
 *         CHKERR( NEPAppendOptionsPrefix(self.nep, cval) )
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets NEP options from the options database. This routine must
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setFromOptions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":297
 *         CHKERR( NEPSetFromOptions(self.nep) )
 * 
 *     def getProblemType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the problem type from the `NEP` object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_23getProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_22getProblemType[] = "NEP.getProblemType(self)\n\n        Gets the problem type from the `NEP` object.\n\n        Returns\n        -------\n        problem_type: `NEP.ProblemType` enumerate\n            The problem type that was previously set.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_23getProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getProblemType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getProblemType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getProblemType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_22getProblemType(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_22getProblemType(struct PySlepcNEPObject *__pyx_v_self) {
  NEPProblemType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getProblemType", 0);

  /* "SLEPc/NEP.pyx":306
 *             The problem type that was previously set.
 *         """
 *         cdef SlepcNEPProblemType val = NEP_GENERAL             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetProblemType(self.nep, &val) )
 *         return val
 */
  __pyx_v_val = NEP_GENERAL;

  /* "SLEPc/NEP.pyx":307
 *         """
 *         cdef SlepcNEPProblemType val = NEP_GENERAL
 *         CHKERR( NEPGetProblemType(self.nep, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetProblemType(__pyx_v_self->nep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 307, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":308
 *         cdef SlepcNEPProblemType val = NEP_GENERAL
 *         CHKERR( NEPGetProblemType(self.nep, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setProblemType(self, problem_type):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_NEPProblemType(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 308, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":297
 *         CHKERR( NEPSetFromOptions(self.nep) )
 * 
 *     def getProblemType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the problem type from the `NEP` object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getProblemType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":310
 *         return val
 * 
 *     def setProblemType(self, problem_type):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the type of the eigenvalue problem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_25setProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_24setProblemType[] = "NEP.setProblemType(self, problem_type)\n\n        Specifies the type of the eigenvalue problem.\n\n        Parameters\n        ----------\n        problem_type: `NEP.ProblemType` enumerate\n            The problem type to be set.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_25setProblemType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_problem_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setProblemType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_problem_type,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_problem_type)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setProblemType") < 0)) __PYX_ERR(20, 310, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_problem_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setProblemType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 310, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setProblemType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_24setProblemType(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_problem_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_24setProblemType(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_problem_type) {
  NEPProblemType __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  NEPProblemType __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setProblemType", 0);

  /* "SLEPc/NEP.pyx":319
 *             The problem type to be set.
 *         """
 *         cdef SlepcNEPProblemType val = problem_type             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSetProblemType(self.nep, val) )
 * 
 */
  __pyx_t_1 = ((NEPProblemType)__Pyx_PyInt_As_NEPProblemType(__pyx_v_problem_type)); if (unlikely(PyErr_Occurred())) __PYX_ERR(20, 319, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/NEP.pyx":320
 *         """
 *         cdef SlepcNEPProblemType val = problem_type
 *         CHKERR( NEPSetProblemType(self.nep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getWhichEigenpairs(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetProblemType(__pyx_v_self->nep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 320, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":310
 *         return val
 * 
 *     def setProblemType(self, problem_type):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies the type of the eigenvalue problem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setProblemType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":322
 *         CHKERR( NEPSetProblemType(self.nep, val) )
 * 
 *     def getWhichEigenpairs(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns which portion of the spectrum is to be sought.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_27getWhichEigenpairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_26getWhichEigenpairs[] = "NEP.getWhichEigenpairs(self)\n\n        Returns which portion of the spectrum is to be sought.\n\n        Returns\n        -------\n        which: `NEP.Which` enumerate\n            The portion of the spectrum to be sought by the solver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_27getWhichEigenpairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getWhichEigenpairs (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getWhichEigenpairs", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getWhichEigenpairs", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_26getWhichEigenpairs(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_26getWhichEigenpairs(struct PySlepcNEPObject *__pyx_v_self) {
  NEPWhich __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getWhichEigenpairs", 0);

  /* "SLEPc/NEP.pyx":331
 *             The portion of the spectrum to be sought by the solver.
 *         """
 *         cdef SlepcNEPWhich val = NEP_LARGEST_MAGNITUDE             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetWhichEigenpairs(self.nep, &val) )
 *         return val
 */
  __pyx_v_val = NEP_LARGEST_MAGNITUDE;

  /* "SLEPc/NEP.pyx":332
 *         """
 *         cdef SlepcNEPWhich val = NEP_LARGEST_MAGNITUDE
 *         CHKERR( NEPGetWhichEigenpairs(self.nep, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetWhichEigenpairs(__pyx_v_self->nep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 332, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":333
 *         cdef SlepcNEPWhich val = NEP_LARGEST_MAGNITUDE
 *         CHKERR( NEPGetWhichEigenpairs(self.nep, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setWhichEigenpairs(self, which):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_NEPWhich(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 333, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":322
 *         CHKERR( NEPSetProblemType(self.nep, val) )
 * 
 *     def getWhichEigenpairs(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns which portion of the spectrum is to be sought.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getWhichEigenpairs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":335
 *         return val
 * 
 *     def setWhichEigenpairs(self, which):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies which portion of the spectrum is to be sought.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_29setWhichEigenpairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_28setWhichEigenpairs[] = "NEP.setWhichEigenpairs(self, which)\n\n        Specifies which portion of the spectrum is to be sought.\n\n        Parameters\n        ----------\n        which: `NEP.Which` enumerate\n            The portion of the spectrum to be sought by the solver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_29setWhichEigenpairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_which = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setWhichEigenpairs (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_which,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_which)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setWhichEigenpairs") < 0)) __PYX_ERR(20, 335, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_which = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setWhichEigenpairs", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 335, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setWhichEigenpairs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_28setWhichEigenpairs(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_which);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_28setWhichEigenpairs(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_which) {
  NEPWhich __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  NEPWhich __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setWhichEigenpairs", 0);

  /* "SLEPc/NEP.pyx":344
 *             The portion of the spectrum to be sought by the solver.
 *         """
 *         cdef SlepcNEPWhich val = which             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSetWhichEigenpairs(self.nep, val) )
 * 
 */
  __pyx_t_1 = ((NEPWhich)__Pyx_PyInt_As_NEPWhich(__pyx_v_which)); if (unlikely(PyErr_Occurred())) __PYX_ERR(20, 344, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/NEP.pyx":345
 *         """
 *         cdef SlepcNEPWhich val = which
 *         CHKERR( NEPSetWhichEigenpairs(self.nep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getTarget(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetWhichEigenpairs(__pyx_v_self->nep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 345, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":335
 *         return val
 * 
 *     def setWhichEigenpairs(self, which):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies which portion of the spectrum is to be sought.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setWhichEigenpairs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":347
 *         CHKERR( NEPSetWhichEigenpairs(self.nep, val) )
 * 
 *     def getTarget(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the value of the target.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_31getTarget(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_30getTarget[] = "NEP.getTarget(self)\n\n        Gets the value of the target.\n\n        Returns\n        -------\n        target: float (real or complex)\n                The value of the target.\n\n        Notes\n        -----\n        If the target was not set by the user, then zero is returned.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_31getTarget(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTarget (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTarget", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTarget", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_30getTarget(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_30getTarget(struct PySlepcNEPObject *__pyx_v_self) {
  PetscScalar __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTarget", 0);

  /* "SLEPc/NEP.pyx":360
 *         If the target was not set by the user, then zero is returned.
 *         """
 *         cdef PetscScalar sval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetTarget(self.nep, &sval) )
 *         return toScalar(sval)
 */
  __pyx_v_sval = 0.0;

  /* "SLEPc/NEP.pyx":361
 *         """
 *         cdef PetscScalar sval = 0
 *         CHKERR( NEPGetTarget(self.nep, &sval) )             # <<<<<<<<<<<<<<
 *         return toScalar(sval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetTarget(__pyx_v_self->nep, (&__pyx_v_sval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 361, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":362
 *         cdef PetscScalar sval = 0
 *         CHKERR( NEPGetTarget(self.nep, &sval) )
 *         return toScalar(sval)             # <<<<<<<<<<<<<<
 * 
 *     def setTarget(self, target):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toScalar(__pyx_v_sval); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 362, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":347
 *         CHKERR( NEPSetWhichEigenpairs(self.nep, val) )
 * 
 *     def getTarget(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the value of the target.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getTarget", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":364
 *         return toScalar(sval)
 * 
 *     def setTarget(self, target):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the value of the target.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_33setTarget(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_32setTarget[] = "NEP.setTarget(self, target)\n\n        Sets the value of the target.\n\n        Parameters\n        ----------\n        target: float (real or complex)\n                The value of the target.\n\n        Notes\n        -----\n        The target is a scalar value used to determine the portion of\n        the spectrum of interest. It is used in combination with\n        `setWhichEigenpairs()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_33setTarget(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_target = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTarget (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_target,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_target)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTarget") < 0)) __PYX_ERR(20, 364, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_target = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTarget", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 364, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setTarget", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_32setTarget(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_target);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_32setTarget(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_target) {
  PetscScalar __pyx_v_sval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTarget", 0);

  /* "SLEPc/NEP.pyx":379
 *         `setWhichEigenpairs()`.
 *         """
 *         cdef PetscScalar sval = asScalar(target)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSetTarget(self.nep, sval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_target); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(20, 379, __pyx_L1_error)
  __pyx_v_sval = __pyx_t_1;

  /* "SLEPc/NEP.pyx":380
 *         """
 *         cdef PetscScalar sval = asScalar(target)
 *         CHKERR( NEPSetTarget(self.nep, sval) )             # <<<<<<<<<<<<<<
 * 
 *     def getTolerances(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetTarget(__pyx_v_self->nep, __pyx_v_sval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 380, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":364
 *         return toScalar(sval)
 * 
 *     def setTarget(self, target):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the value of the target.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setTarget", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":382
 *         CHKERR( NEPSetTarget(self.nep, sval) )
 * 
 *     def getTolerances(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance and maximum iteration count used by the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_35getTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_34getTolerances[] = "NEP.getTolerances(self)\n\n        Gets the tolerance and maximum iteration count used by the\n        default NEP convergence tests.\n\n        Returns\n        -------\n        tol: float\n            The convergence tolerance.\n        maxit: int\n            The maximum number of iterations.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_35getTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTolerances (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTolerances", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTolerances", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_34getTolerances(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_34getTolerances(struct PySlepcNEPObject *__pyx_v_self) {
  PetscReal __pyx_v_rval;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTolerances", 0);

  /* "SLEPc/NEP.pyx":394
 *             The maximum number of iterations.
 *         """
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = 0
 *         CHKERR( NEPGetTolerances(self.nep, &rval, &ival) )
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/NEP.pyx":395
 *         """
 *         cdef PetscReal rval = 0
 *         cdef PetscInt  ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetTolerances(self.nep, &rval, &ival) )
 *         return (toReal(rval), toInt(ival))
 */
  __pyx_v_ival = 0;

  /* "SLEPc/NEP.pyx":396
 *         cdef PetscReal rval = 0
 *         cdef PetscInt  ival = 0
 *         CHKERR( NEPGetTolerances(self.nep, &rval, &ival) )             # <<<<<<<<<<<<<<
 *         return (toReal(rval), toInt(ival))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetTolerances(__pyx_v_self->nep, (&__pyx_v_rval), (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 396, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":397
 *         cdef PetscInt  ival = 0
 *         CHKERR( NEPGetTolerances(self.nep, &rval, &ival) )
 *         return (toReal(rval), toInt(ival))             # <<<<<<<<<<<<<<
 * 
 *     def setTolerances(self, tol=None, maxit=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 397, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 397, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 397, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":382
 *         CHKERR( NEPSetTarget(self.nep, sval) )
 * 
 *     def getTolerances(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance and maximum iteration count used by the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":399
 *         return (toReal(rval), toInt(ival))
 * 
 *     def setTolerances(self, tol=None, maxit=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance and maximum iteration count used in convergence tests.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_37setTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_36setTolerances[] = "NEP.setTolerances(self, tol=None, maxit=None)\n\n        Sets the tolerance and maximum iteration count used in convergence tests.\n\n        Parameters\n        ----------\n        tol: float, optional\n            The convergence tolerance.\n        maxit: int, optional\n            The maximum number of iterations.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_37setTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_tol = 0;
  PyObject *__pyx_v_maxit = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTolerances (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_tol,&__pyx_n_s_maxit,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tol);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_maxit);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTolerances") < 0)) __PYX_ERR(20, 399, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_tol = values[0];
    __pyx_v_maxit = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTolerances", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 399, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_36setTolerances(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_tol, __pyx_v_maxit);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_36setTolerances(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_tol, PyObject *__pyx_v_maxit) {
  PetscReal __pyx_v_rval;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscReal __pyx_t_3;
  PetscInt __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTolerances", 0);

  /* "SLEPc/NEP.pyx":410
 *             The maximum number of iterations.
 *         """
 *         cdef PetscReal rval = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol   is not None: rval = asReal(tol)
 */
  __pyx_v_rval = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":411
 *         """
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if tol   is not None: rval = asReal(tol)
 *         if maxit is not None: ival = asInt(maxit)
 */
  __pyx_v_ival = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":412
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol   is not None: rval = asReal(tol)             # <<<<<<<<<<<<<<
 *         if maxit is not None: ival = asInt(maxit)
 *         CHKERR( NEPSetTolerances(self.nep, rval, ival) )
 */
  __pyx_t_1 = (__pyx_v_tol != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_tol); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(20, 412, __pyx_L1_error)
    __pyx_v_rval = __pyx_t_3;
  }

  /* "SLEPc/NEP.pyx":413
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol   is not None: rval = asReal(tol)
 *         if maxit is not None: ival = asInt(maxit)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSetTolerances(self.nep, rval, ival) )
 * 
 */
  __pyx_t_2 = (__pyx_v_maxit != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_maxit); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 413, __pyx_L1_error)
    __pyx_v_ival = __pyx_t_4;
  }

  /* "SLEPc/NEP.pyx":414
 *         if tol   is not None: rval = asReal(tol)
 *         if maxit is not None: ival = asInt(maxit)
 *         CHKERR( NEPSetTolerances(self.nep, rval, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getConvergenceTest(self):
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetTolerances(__pyx_v_self->nep, __pyx_v_rval, __pyx_v_ival)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(20, 414, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":399
 *         return (toReal(rval), toInt(ival))
 * 
 *     def setTolerances(self, tol=None, maxit=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance and maximum iteration count used in convergence tests.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":416
 *         CHKERR( NEPSetTolerances(self.nep, rval, ival) )
 * 
 *     def getConvergenceTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Return the method used to compute the error estimate
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_39getConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_38getConvergenceTest[] = "NEP.getConvergenceTest(self)\n\n        Return the method used to compute the error estimate\n        used in the convergence test.\n\n        Returns\n        -------\n        conv: NEP.Conv\n            The method used to compute the error estimate\n            used in the convergence test.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_39getConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getConvergenceTest (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getConvergenceTest", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConvergenceTest", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_38getConvergenceTest(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_38getConvergenceTest(struct PySlepcNEPObject *__pyx_v_self) {
  NEPConv __pyx_v_conv;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getConvergenceTest", 0);

  /* "SLEPc/NEP.pyx":427
 *             used in the convergence test.
 *         """
 *         cdef SlepcNEPConv conv = NEP_CONV_REL             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetConvergenceTest(self.nep, &conv) )
 *         return conv
 */
  __pyx_v_conv = NEP_CONV_REL;

  /* "SLEPc/NEP.pyx":428
 *         """
 *         cdef SlepcNEPConv conv = NEP_CONV_REL
 *         CHKERR( NEPGetConvergenceTest(self.nep, &conv) )             # <<<<<<<<<<<<<<
 *         return conv
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetConvergenceTest(__pyx_v_self->nep, (&__pyx_v_conv))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 428, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":429
 *         cdef SlepcNEPConv conv = NEP_CONV_REL
 *         CHKERR( NEPGetConvergenceTest(self.nep, &conv) )
 *         return conv             # <<<<<<<<<<<<<<
 * 
 *     def setConvergenceTest(self, conv):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_NEPConv(__pyx_v_conv); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 429, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":416
 *         CHKERR( NEPSetTolerances(self.nep, rval, ival) )
 * 
 *     def getConvergenceTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Return the method used to compute the error estimate
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getConvergenceTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":431
 *         return conv
 * 
 *     def setConvergenceTest(self, conv):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies how to compute the error estimate
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_41setConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_40setConvergenceTest[] = "NEP.setConvergenceTest(self, conv)\n\n        Specifies how to compute the error estimate\n        used in the convergence test.\n\n        Parameters\n        ----------\n        conv: NEP.Conv\n            The method used to compute the error estimate\n            used in the convergence test.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_41setConvergenceTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_conv = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setConvergenceTest (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_conv,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_conv)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setConvergenceTest") < 0)) __PYX_ERR(20, 431, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_conv = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setConvergenceTest", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 431, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setConvergenceTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_40setConvergenceTest(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_conv);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_40setConvergenceTest(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_conv) {
  NEPConv __pyx_v_tconv;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  NEPConv __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setConvergenceTest", 0);

  /* "SLEPc/NEP.pyx":442
 *             used in the convergence test.
 *         """
 *         cdef SlepcNEPConv tconv = conv             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSetConvergenceTest(self.nep, tconv) )
 * 
 */
  __pyx_t_1 = ((NEPConv)__Pyx_PyInt_As_NEPConv(__pyx_v_conv)); if (unlikely(PyErr_Occurred())) __PYX_ERR(20, 442, __pyx_L1_error)
  __pyx_v_tconv = __pyx_t_1;

  /* "SLEPc/NEP.pyx":443
 *         """
 *         cdef SlepcNEPConv tconv = conv
 *         CHKERR( NEPSetConvergenceTest(self.nep, tconv) )             # <<<<<<<<<<<<<<
 * 
 *     def getRefine(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetConvergenceTest(__pyx_v_self->nep, __pyx_v_tconv)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 443, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":431
 *         return conv
 * 
 *     def setConvergenceTest(self, conv):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies how to compute the error estimate
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setConvergenceTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":445
 *         CHKERR( NEPSetConvergenceTest(self.nep, tconv) )
 * 
 *     def getRefine(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the refinement strategy used by the NEP object,
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_43getRefine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_42getRefine[] = "NEP.getRefine(self)\n\n        Gets the refinement strategy used by the NEP object,\n        and the associated parameters.\n\n        Returns\n        -------\n        ref: NEP.Refine\n            The refinement type.\n        npart: int\n            The number of partitions of the communicator.\n        tol: real\n            The convergence tolerance.\n        its: int\n            The maximum number of refinement iterations.\n        scheme: NEP.RefineScheme\n            Scheme for solving linear systems\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_43getRefine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRefine (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRefine", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRefine", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_42getRefine(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_42getRefine(struct PySlepcNEPObject *__pyx_v_self) {
  NEPRefine __pyx_v_ref;
  PetscInt __pyx_v_npart;
  PetscReal __pyx_v_tol;
  PetscInt __pyx_v_its;
  NEPRefineScheme __pyx_v_scheme;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRefine", 0);

  /* "SLEPc/NEP.pyx":463
 *             Scheme for solving linear systems
 *         """
 *         cdef SlepcNEPRefine ref = NEP_REFINE_NONE             # <<<<<<<<<<<<<<
 *         cdef PetscInt npart = 1
 *         cdef PetscReal tol = PETSC_DEFAULT
 */
  __pyx_v_ref = NEP_REFINE_NONE;

  /* "SLEPc/NEP.pyx":464
 *         """
 *         cdef SlepcNEPRefine ref = NEP_REFINE_NONE
 *         cdef PetscInt npart = 1             # <<<<<<<<<<<<<<
 *         cdef PetscReal tol = PETSC_DEFAULT
 *         cdef PetscInt its = PETSC_DEFAULT
 */
  __pyx_v_npart = 1;

  /* "SLEPc/NEP.pyx":465
 *         cdef SlepcNEPRefine ref = NEP_REFINE_NONE
 *         cdef PetscInt npart = 1
 *         cdef PetscReal tol = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt its = PETSC_DEFAULT
 *         cdef SlepcNEPRefineScheme scheme = NEP_REFINE_SCHEME_MBE
 */
  __pyx_v_tol = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":466
 *         cdef PetscInt npart = 1
 *         cdef PetscReal tol = PETSC_DEFAULT
 *         cdef PetscInt its = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef SlepcNEPRefineScheme scheme = NEP_REFINE_SCHEME_MBE
 *         CHKERR( NEPGetRefine(self.nep, &ref, &npart, &tol, &its, &scheme) )
 */
  __pyx_v_its = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":467
 *         cdef PetscReal tol = PETSC_DEFAULT
 *         cdef PetscInt its = PETSC_DEFAULT
 *         cdef SlepcNEPRefineScheme scheme = NEP_REFINE_SCHEME_MBE             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetRefine(self.nep, &ref, &npart, &tol, &its, &scheme) )
 *         return (ref, toInt(npart), toReal(tol), toInt(its), scheme)
 */
  __pyx_v_scheme = NEP_REFINE_SCHEME_MBE;

  /* "SLEPc/NEP.pyx":468
 *         cdef PetscInt its = PETSC_DEFAULT
 *         cdef SlepcNEPRefineScheme scheme = NEP_REFINE_SCHEME_MBE
 *         CHKERR( NEPGetRefine(self.nep, &ref, &npart, &tol, &its, &scheme) )             # <<<<<<<<<<<<<<
 *         return (ref, toInt(npart), toReal(tol), toInt(its), scheme)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetRefine(__pyx_v_self->nep, (&__pyx_v_ref), (&__pyx_v_npart), (&__pyx_v_tol), (&__pyx_v_its), (&__pyx_v_scheme))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 468, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":469
 *         cdef SlepcNEPRefineScheme scheme = NEP_REFINE_SCHEME_MBE
 *         CHKERR( NEPGetRefine(self.nep, &ref, &npart, &tol, &its, &scheme) )
 *         return (ref, toInt(npart), toReal(tol), toInt(its), scheme)             # <<<<<<<<<<<<<<
 * 
 *     def setRefine(self, ref, npart=None, tol=None, its=None, scheme=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_NEPRefine(__pyx_v_ref); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 469, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_npart); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 469, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_tol); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 469, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_its); if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 469, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyInt_From_NEPRefineScheme(__pyx_v_scheme); if (unlikely(!__pyx_t_6)) __PYX_ERR(20, 469, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 469, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_7, 4, __pyx_t_6);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_t_6 = 0;
  __pyx_r = __pyx_t_7;
  __pyx_t_7 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":445
 *         CHKERR( NEPSetConvergenceTest(self.nep, tconv) )
 * 
 *     def getRefine(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the refinement strategy used by the NEP object,
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getRefine", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":471
 *         return (ref, toInt(npart), toReal(tol), toInt(its), scheme)
 * 
 *     def setRefine(self, ref, npart=None, tol=None, its=None, scheme=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the refinement strategy used by the NEP object,
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_45setRefine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_44setRefine[] = "NEP.setRefine(self, ref, npart=None, tol=None, its=None, scheme=None)\n\n        Sets the refinement strategy used by the NEP object,\n        and the associated parameters.\n\n        Parameters\n        ----------\n        ref: NEP.Refine\n            The refinement type.\n        npart: int, optional\n            The number of partitions of the communicator.\n        tol: real, optional\n            The convergence tolerance.\n        its: int, optional\n            The maximum number of refinement iterations.\n        scheme: NEP.RefineScheme, optional\n            Scheme for linear system solves\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_45setRefine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_ref = 0;
  PyObject *__pyx_v_npart = 0;
  PyObject *__pyx_v_tol = 0;
  PyObject *__pyx_v_its = 0;
  PyObject *__pyx_v_scheme = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRefine (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ref,&__pyx_n_s_npart,&__pyx_n_s_tol,&__pyx_n_s_its,&__pyx_n_s_scheme,0};
    PyObject* values[5] = {0,0,0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    values[3] = ((PyObject *)Py_None);
    values[4] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ref)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_npart);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tol);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_its);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_scheme);
          if (value) { values[4] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRefine") < 0)) __PYX_ERR(20, 471, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_ref = values[0];
    __pyx_v_npart = values[1];
    __pyx_v_tol = values[2];
    __pyx_v_its = values[3];
    __pyx_v_scheme = values[4];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRefine", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 471, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRefine", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_44setRefine(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_ref, __pyx_v_npart, __pyx_v_tol, __pyx_v_its, __pyx_v_scheme);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_44setRefine(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_ref, PyObject *__pyx_v_npart, PyObject *__pyx_v_tol, PyObject *__pyx_v_its, PyObject *__pyx_v_scheme) {
  NEPRefine __pyx_v_tref;
  PetscInt __pyx_v_tnpart;
  PetscReal __pyx_v_ttol;
  PetscInt __pyx_v_tits;
  NEPRefineScheme __pyx_v_tscheme;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  NEPRefine __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PetscInt __pyx_t_4;
  PetscReal __pyx_t_5;
  NEPRefineScheme __pyx_t_6;
  int __pyx_t_7;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRefine", 0);

  /* "SLEPc/NEP.pyx":489
 *             Scheme for linear system solves
 *         """
 *         cdef SlepcNEPRefine tref = ref             # <<<<<<<<<<<<<<
 *         cdef PetscInt tnpart = 1
 *         cdef PetscReal ttol = PETSC_DEFAULT
 */
  __pyx_t_1 = ((NEPRefine)__Pyx_PyInt_As_NEPRefine(__pyx_v_ref)); if (unlikely(PyErr_Occurred())) __PYX_ERR(20, 489, __pyx_L1_error)
  __pyx_v_tref = __pyx_t_1;

  /* "SLEPc/NEP.pyx":490
 *         """
 *         cdef SlepcNEPRefine tref = ref
 *         cdef PetscInt tnpart = 1             # <<<<<<<<<<<<<<
 *         cdef PetscReal ttol = PETSC_DEFAULT
 *         cdef PetscInt tits = PETSC_DEFAULT
 */
  __pyx_v_tnpart = 1;

  /* "SLEPc/NEP.pyx":491
 *         cdef SlepcNEPRefine tref = ref
 *         cdef PetscInt tnpart = 1
 *         cdef PetscReal ttol = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt tits = PETSC_DEFAULT
 *         cdef SlepcNEPRefineScheme tscheme = NEP_REFINE_SCHEME_MBE
 */
  __pyx_v_ttol = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":492
 *         cdef PetscInt tnpart = 1
 *         cdef PetscReal ttol = PETSC_DEFAULT
 *         cdef PetscInt tits = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef SlepcNEPRefineScheme tscheme = NEP_REFINE_SCHEME_MBE
 *         if npart is not None: tnpart = asInt(npart)
 */
  __pyx_v_tits = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":493
 *         cdef PetscReal ttol = PETSC_DEFAULT
 *         cdef PetscInt tits = PETSC_DEFAULT
 *         cdef SlepcNEPRefineScheme tscheme = NEP_REFINE_SCHEME_MBE             # <<<<<<<<<<<<<<
 *         if npart is not None: tnpart = asInt(npart)
 *         if tol is not None: ttol = asReal(tol)
 */
  __pyx_v_tscheme = NEP_REFINE_SCHEME_MBE;

  /* "SLEPc/NEP.pyx":494
 *         cdef PetscInt tits = PETSC_DEFAULT
 *         cdef SlepcNEPRefineScheme tscheme = NEP_REFINE_SCHEME_MBE
 *         if npart is not None: tnpart = asInt(npart)             # <<<<<<<<<<<<<<
 *         if tol is not None: ttol = asReal(tol)
 *         if its is not None: tits = asInt(its)
 */
  __pyx_t_2 = (__pyx_v_npart != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_npart); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 494, __pyx_L1_error)
    __pyx_v_tnpart = __pyx_t_4;
  }

  /* "SLEPc/NEP.pyx":495
 *         cdef SlepcNEPRefineScheme tscheme = NEP_REFINE_SCHEME_MBE
 *         if npart is not None: tnpart = asInt(npart)
 *         if tol is not None: ttol = asReal(tol)             # <<<<<<<<<<<<<<
 *         if its is not None: tits = asInt(its)
 *         if scheme is not None: tscheme = scheme
 */
  __pyx_t_3 = (__pyx_v_tol != Py_None);
  __pyx_t_2 = (__pyx_t_3 != 0);
  if (__pyx_t_2) {
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_tol); if (unlikely(__pyx_t_5 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(20, 495, __pyx_L1_error)
    __pyx_v_ttol = __pyx_t_5;
  }

  /* "SLEPc/NEP.pyx":496
 *         if npart is not None: tnpart = asInt(npart)
 *         if tol is not None: ttol = asReal(tol)
 *         if its is not None: tits = asInt(its)             # <<<<<<<<<<<<<<
 *         if scheme is not None: tscheme = scheme
 *         CHKERR( NEPSetRefine(self.nep, tref, tnpart, ttol, tits, tscheme) )
 */
  __pyx_t_2 = (__pyx_v_its != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_its); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 496, __pyx_L1_error)
    __pyx_v_tits = __pyx_t_4;
  }

  /* "SLEPc/NEP.pyx":497
 *         if tol is not None: ttol = asReal(tol)
 *         if its is not None: tits = asInt(its)
 *         if scheme is not None: tscheme = scheme             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSetRefine(self.nep, tref, tnpart, ttol, tits, tscheme) )
 * 
 */
  __pyx_t_3 = (__pyx_v_scheme != Py_None);
  __pyx_t_2 = (__pyx_t_3 != 0);
  if (__pyx_t_2) {
    __pyx_t_6 = ((NEPRefineScheme)__Pyx_PyInt_As_NEPRefineScheme(__pyx_v_scheme)); if (unlikely(PyErr_Occurred())) __PYX_ERR(20, 497, __pyx_L1_error)
    __pyx_v_tscheme = __pyx_t_6;
  }

  /* "SLEPc/NEP.pyx":498
 *         if its is not None: tits = asInt(its)
 *         if scheme is not None: tscheme = scheme
 *         CHKERR( NEPSetRefine(self.nep, tref, tnpart, ttol, tits, tscheme) )             # <<<<<<<<<<<<<<
 * 
 *     def getRefineKSP(self):
 */
  __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetRefine(__pyx_v_self->nep, __pyx_v_tref, __pyx_v_tnpart, __pyx_v_ttol, __pyx_v_tits, __pyx_v_tscheme)); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(20, 498, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":471
 *         return (ref, toInt(npart), toReal(tol), toInt(its), scheme)
 * 
 *     def setRefine(self, ref, npart=None, tol=None, its=None, scheme=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the refinement strategy used by the NEP object,
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRefine", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":500
 *         CHKERR( NEPSetRefine(self.nep, tref, tnpart, ttol, tits, tscheme) )
 * 
 *     def getRefineKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the `KSP` object used by the eigensolver in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_47getRefineKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_46getRefineKSP[] = "NEP.getRefineKSP(self)\n\n        Obtain the `KSP` object used by the eigensolver in the\n        refinement phase.\n\n        Returns\n        -------\n        ksp: `KSP`\n             The linear solver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_47getRefineKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRefineKSP (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRefineKSP", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRefineKSP", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_46getRefineKSP(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_46getRefineKSP(struct PySlepcNEPObject *__pyx_v_self) {
  struct PyPetscKSPObject *__pyx_v_ksp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRefineKSP", 0);

  /* "SLEPc/NEP.pyx":510
 *              The linear solver object.
 *         """
 *         cdef KSP ksp = KSP()             # <<<<<<<<<<<<<<
 *         CHKERR( NEPRefineGetKSP(self.nep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_KSP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 510, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ksp = ((struct PyPetscKSPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":511
 *         """
 *         cdef KSP ksp = KSP()
 *         CHKERR( NEPRefineGetKSP(self.nep, &ksp.ksp) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(ksp.obj)
 *         return ksp
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPRefineGetKSP(__pyx_v_self->nep, (&__pyx_v_ksp->ksp))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 511, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":512
 *         cdef KSP ksp = KSP()
 *         CHKERR( NEPRefineGetKSP(self.nep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)             # <<<<<<<<<<<<<<
 *         return ksp
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ksp->__pyx_base.obj));

  /* "SLEPc/NEP.pyx":513
 *         CHKERR( NEPRefineGetKSP(self.nep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 *         return ksp             # <<<<<<<<<<<<<<
 * 
 *     def getTrackAll(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ksp));
  __pyx_r = ((PyObject *)__pyx_v_ksp);
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":500
 *         CHKERR( NEPSetRefine(self.nep, tref, tnpart, ttol, tits, tscheme) )
 * 
 *     def getRefineKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the `KSP` object used by the eigensolver in the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getRefineKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ksp);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":515
 *         return ksp
 * 
 *     def getTrackAll(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether all residual norms must be
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_49getTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_48getTrackAll[] = "NEP.getTrackAll(self)\n\n        Returns the flag indicating whether all residual norms must be\n        computed or not.\n\n        Returns\n        -------\n        trackall: bool\n            Whether the solver compute all residuals or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_49getTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTrackAll (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTrackAll", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTrackAll", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_48getTrackAll(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_48getTrackAll(struct PySlepcNEPObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTrackAll", 0);

  /* "SLEPc/NEP.pyx":525
 *             Whether the solver compute all residuals or not.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetTrackAll(self.nep, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/NEP.pyx":526
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( NEPGetTrackAll(self.nep, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetTrackAll(__pyx_v_self->nep, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 526, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":527
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( NEPGetTrackAll(self.nep, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setTrackAll(self, trackall):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 527, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":515
 *         return ksp
 * 
 *     def getTrackAll(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether all residual norms must be
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getTrackAll", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":529
 *         return toBool(tval)
 * 
 *     def setTrackAll(self, trackall):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies if the solver must compute the residual of all
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_51setTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_50setTrackAll[] = "NEP.setTrackAll(self, trackall)\n\n        Specifies if the solver must compute the residual of all\n        approximate eigenpairs or not.\n\n        Parameters\n        ----------\n        trackall: bool\n            Whether compute all residuals or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_51setTrackAll(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_trackall = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTrackAll (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_trackall,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_trackall)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTrackAll") < 0)) __PYX_ERR(20, 529, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_trackall = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTrackAll", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 529, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setTrackAll", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_50setTrackAll(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_trackall);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_50setTrackAll(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_trackall) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTrackAll", 0);

  /* "SLEPc/NEP.pyx":539
 *             Whether compute all residuals or not.
 *         """
 *         cdef PetscBool tval = trackall             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSetTrackAll(self.nep, tval) )
 * 
 */
  __pyx_t_1 = ((PetscBool)__Pyx_PyInt_As_PetscBool(__pyx_v_trackall)); if (unlikely(PyErr_Occurred())) __PYX_ERR(20, 539, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/NEP.pyx":540
 *         """
 *         cdef PetscBool tval = trackall
 *         CHKERR( NEPSetTrackAll(self.nep, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getDimensions(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetTrackAll(__pyx_v_self->nep, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 540, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":529
 *         return toBool(tval)
 * 
 *     def setTrackAll(self, trackall):             # <<<<<<<<<<<<<<
 *         """
 *         Specifies if the solver must compute the residual of all
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setTrackAll", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":542
 *         CHKERR( NEPSetTrackAll(self.nep, tval) )
 * 
 *     def getDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of eigenvalues to compute and the dimension of
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_53getDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_52getDimensions[] = "NEP.getDimensions(self)\n\n        Gets the number of eigenvalues to compute and the dimension of\n        the subspace.\n\n        Returns\n        -------\n        nev: int\n            Number of eigenvalues to compute.\n        ncv: int\n            Maximum dimension of the subspace to be used by the solver.\n        mpd: int\n            Maximum dimension allowed for the projected problem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_53getDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDimensions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getDimensions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDimensions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_52getDimensions(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_52getDimensions(struct PySlepcNEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getDimensions", 0);

  /* "SLEPc/NEP.pyx":556
 *             Maximum dimension allowed for the projected problem.
 *         """
 *         cdef PetscInt ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/NEP.pyx":557
 *         """
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival3 = 0
 *         CHKERR( NEPGetDimensions(self.nep, &ival1, &ival2, &ival3) )
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/NEP.pyx":558
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetDimensions(self.nep, &ival1, &ival2, &ival3) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 */
  __pyx_v_ival3 = 0;

  /* "SLEPc/NEP.pyx":559
 *         cdef PetscInt ival2 = 0
 *         cdef PetscInt ival3 = 0
 *         CHKERR( NEPGetDimensions(self.nep, &ival1, &ival2, &ival3) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetDimensions(__pyx_v_self->nep, (&__pyx_v_ival1), (&__pyx_v_ival2), (&__pyx_v_ival3))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 559, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":560
 *         cdef PetscInt ival3 = 0
 *         CHKERR( NEPGetDimensions(self.nep, &ival1, &ival2, &ival3) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))             # <<<<<<<<<<<<<<
 * 
 *     def setDimensions(self, nev=None, ncv=None, mpd=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 560, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 560, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival3); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 560, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 560, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":542
 *         CHKERR( NEPSetTrackAll(self.nep, tval) )
 * 
 *     def getDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of eigenvalues to compute and the dimension of
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":562
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 *     def setDimensions(self, nev=None, ncv=None, mpd=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of eigenvalues to compute and the dimension of
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_55setDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_54setDimensions[] = "NEP.setDimensions(self, nev=None, ncv=None, mpd=None)\n\n        Sets the number of eigenvalues to compute and the dimension of\n        the subspace.\n\n        Parameters\n        ----------\n        nev: int, optional\n            Number of eigenvalues to compute.\n        ncv: int, optional\n            Maximum dimension of the subspace to be used by the\n            solver.\n        mpd: int, optional\n            Maximum dimension allowed for the projected problem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_55setDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nev = 0;
  PyObject *__pyx_v_ncv = 0;
  PyObject *__pyx_v_mpd = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setDimensions (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nev,&__pyx_n_s_ncv,&__pyx_n_s_mpd,0};
    PyObject* values[3] = {0,0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nev);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ncv);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mpd);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setDimensions") < 0)) __PYX_ERR(20, 562, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_nev = values[0];
    __pyx_v_ncv = values[1];
    __pyx_v_mpd = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setDimensions", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 562, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_54setDimensions(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_nev, __pyx_v_ncv, __pyx_v_mpd);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_54setDimensions(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_nev, PyObject *__pyx_v_ncv, PyObject *__pyx_v_mpd) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setDimensions", 0);

  /* "SLEPc/NEP.pyx":577
 *             Maximum dimension allowed for the projected problem.
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":578
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":579
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)
 */
  __pyx_v_ival3 = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":580
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)             # <<<<<<<<<<<<<<
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)
 */
  __pyx_t_1 = (__pyx_v_nev != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_nev); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 580, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_3;
  }

  /* "SLEPc/NEP.pyx":581
 *         cdef PetscInt ival3 = PETSC_DEFAULT
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)             # <<<<<<<<<<<<<<
 *         if mpd is not None: ival3 = asInt(mpd)
 *         CHKERR( NEPSetDimensions(self.nep, ival1, ival2, ival3) )
 */
  __pyx_t_2 = (__pyx_v_ncv != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_ncv); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 581, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_3;
  }

  /* "SLEPc/NEP.pyx":582
 *         if nev is not None: ival1 = asInt(nev)
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSetDimensions(self.nep, ival1, ival2, ival3) )
 * 
 */
  __pyx_t_1 = (__pyx_v_mpd != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_mpd); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 582, __pyx_L1_error)
    __pyx_v_ival3 = __pyx_t_3;
  }

  /* "SLEPc/NEP.pyx":583
 *         if ncv is not None: ival2 = asInt(ncv)
 *         if mpd is not None: ival3 = asInt(mpd)
 *         CHKERR( NEPSetDimensions(self.nep, ival1, ival2, ival3) )             # <<<<<<<<<<<<<<
 * 
 *     def getBV(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetDimensions(__pyx_v_self->nep, __pyx_v_ival1, __pyx_v_ival2, __pyx_v_ival3)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(20, 583, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":562
 *         return (toInt(ival1), toInt(ival2), toInt(ival3))
 * 
 *     def setDimensions(self, nev=None, ncv=None, mpd=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the number of eigenvalues to compute and the dimension of
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":585
 *         CHKERR( NEPSetDimensions(self.nep, ival1, ival2, ival3) )
 * 
 *     def getBV(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the basis vectors object associated to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_57getBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_56getBV[] = "NEP.getBV(self)\n\n        Obtain the basis vectors object associated to the eigensolver.\n\n        Returns\n        -------\n        bv: BV\n            The basis vectors context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_57getBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getBV (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getBV", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBV", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_56getBV(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_56getBV(struct PySlepcNEPObject *__pyx_v_self) {
  struct PySlepcBVObject *__pyx_v_bv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getBV", 0);

  /* "SLEPc/NEP.pyx":594
 *             The basis vectors context.
 *         """
 *         cdef BV bv = BV()             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetBV(self.nep, &bv.bv) )
 *         PetscINCREF(bv.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 594, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_bv = ((struct PySlepcBVObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":595
 *         """
 *         cdef BV bv = BV()
 *         CHKERR( NEPGetBV(self.nep, &bv.bv) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(bv.obj)
 *         return bv
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetBV(__pyx_v_self->nep, (&__pyx_v_bv->bv))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 595, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":596
 *         cdef BV bv = BV()
 *         CHKERR( NEPGetBV(self.nep, &bv.bv) )
 *         PetscINCREF(bv.obj)             # <<<<<<<<<<<<<<
 *         return bv
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_bv->__pyx_base.obj));

  /* "SLEPc/NEP.pyx":597
 *         CHKERR( NEPGetBV(self.nep, &bv.bv) )
 *         PetscINCREF(bv.obj)
 *         return bv             # <<<<<<<<<<<<<<
 * 
 *     def setBV(self, BV bv):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_bv));
  __pyx_r = ((PyObject *)__pyx_v_bv);
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":585
 *         CHKERR( NEPSetDimensions(self.nep, ival1, ival2, ival3) )
 * 
 *     def getBV(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the basis vectors object associated to the eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_bv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":599
 *         return bv
 * 
 *     def setBV(self, BV bv):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a basis vectors object to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_59setBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_58setBV[] = "NEP.setBV(self, BV bv)\n\n        Associates a basis vectors object to the eigensolver.\n\n        Parameters\n        ----------\n        bv: BV\n            The basis vectors context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_59setBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcBVObject *__pyx_v_bv = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setBV (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bv,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bv)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setBV") < 0)) __PYX_ERR(20, 599, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_bv = ((struct PySlepcBVObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setBV", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 599, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_bv), __pyx_ptype_8slepc4py_5SLEPc_BV, 0, "bv", 0))) __PYX_ERR(20, 599, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_58setBV(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_bv);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_58setBV(struct PySlepcNEPObject *__pyx_v_self, struct PySlepcBVObject *__pyx_v_bv) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setBV", 0);

  /* "SLEPc/NEP.pyx":608
 *             The basis vectors context.
 *         """
 *         CHKERR( NEPSetBV(self.nep, bv.bv) )             # <<<<<<<<<<<<<<
 * 
 *     def getRG(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetBV(__pyx_v_self->nep, __pyx_v_bv->bv)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 608, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":599
 *         return bv
 * 
 *     def setBV(self, BV bv):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a basis vectors object to the eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":610
 *         CHKERR( NEPSetBV(self.nep, bv.bv) )
 * 
 *     def getRG(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the region object associated to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_61getRG(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_60getRG[] = "NEP.getRG(self)\n\n        Obtain the region object associated to the eigensolver.\n\n        Returns\n        -------\n        rg: RG\n            The region context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_61getRG(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRG (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRG", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRG", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_60getRG(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_60getRG(struct PySlepcNEPObject *__pyx_v_self) {
  struct PySlepcRGObject *__pyx_v_rg = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRG", 0);

  /* "SLEPc/NEP.pyx":619
 *             The region context.
 *         """
 *         cdef RG rg = RG()             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetRG(self.nep, &rg.rg) )
 *         PetscINCREF(rg.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_RG)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 619, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_rg = ((struct PySlepcRGObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":620
 *         """
 *         cdef RG rg = RG()
 *         CHKERR( NEPGetRG(self.nep, &rg.rg) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(rg.obj)
 *         return rg
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetRG(__pyx_v_self->nep, (&__pyx_v_rg->rg))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 620, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":621
 *         cdef RG rg = RG()
 *         CHKERR( NEPGetRG(self.nep, &rg.rg) )
 *         PetscINCREF(rg.obj)             # <<<<<<<<<<<<<<
 *         return rg
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_rg->__pyx_base.obj));

  /* "SLEPc/NEP.pyx":622
 *         CHKERR( NEPGetRG(self.nep, &rg.rg) )
 *         PetscINCREF(rg.obj)
 *         return rg             # <<<<<<<<<<<<<<
 * 
 *     def setRG(self, RG rg):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_rg));
  __pyx_r = ((PyObject *)__pyx_v_rg);
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":610
 *         CHKERR( NEPSetBV(self.nep, bv.bv) )
 * 
 *     def getRG(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the region object associated to the eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getRG", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_rg);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":624
 *         return rg
 * 
 *     def setRG(self, RG rg):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a region object to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_63setRG(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_62setRG[] = "NEP.setRG(self, RG rg)\n\n        Associates a region object to the eigensolver.\n\n        Parameters\n        ----------\n        rg: RG\n            The region context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_63setRG(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcRGObject *__pyx_v_rg = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRG (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rg,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rg)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRG") < 0)) __PYX_ERR(20, 624, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_rg = ((struct PySlepcRGObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRG", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 624, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRG", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rg), __pyx_ptype_8slepc4py_5SLEPc_RG, 0, "rg", 0))) __PYX_ERR(20, 624, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_62setRG(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_rg);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_62setRG(struct PySlepcNEPObject *__pyx_v_self, struct PySlepcRGObject *__pyx_v_rg) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRG", 0);

  /* "SLEPc/NEP.pyx":633
 *             The region context.
 *         """
 *         CHKERR( NEPSetRG(self.nep, rg.rg) )             # <<<<<<<<<<<<<<
 * 
 *     def getDS(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetRG(__pyx_v_self->nep, __pyx_v_rg->rg)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 633, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":624
 *         return rg
 * 
 *     def setRG(self, RG rg):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a region object to the eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRG", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":635
 *         CHKERR( NEPSetRG(self.nep, rg.rg) )
 * 
 *     def getDS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the direct solver associated to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_65getDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_64getDS[] = "NEP.getDS(self)\n\n        Obtain the direct solver associated to the eigensolver.\n\n        Returns\n        -------\n        ds: DS\n            The direct solver context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_65getDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDS (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getDS", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDS", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_64getDS(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_64getDS(struct PySlepcNEPObject *__pyx_v_self) {
  struct PySlepcDSObject *__pyx_v_ds = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getDS", 0);

  /* "SLEPc/NEP.pyx":644
 *             The direct solver context.
 *         """
 *         cdef DS ds = DS()             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetDS(self.nep, &ds.ds) )
 *         PetscINCREF(ds.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_DS)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 644, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ds = ((struct PySlepcDSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":645
 *         """
 *         cdef DS ds = DS()
 *         CHKERR( NEPGetDS(self.nep, &ds.ds) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(ds.obj)
 *         return ds
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetDS(__pyx_v_self->nep, (&__pyx_v_ds->ds))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 645, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":646
 *         cdef DS ds = DS()
 *         CHKERR( NEPGetDS(self.nep, &ds.ds) )
 *         PetscINCREF(ds.obj)             # <<<<<<<<<<<<<<
 *         return ds
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ds->__pyx_base.obj));

  /* "SLEPc/NEP.pyx":647
 *         CHKERR( NEPGetDS(self.nep, &ds.ds) )
 *         PetscINCREF(ds.obj)
 *         return ds             # <<<<<<<<<<<<<<
 * 
 *     def setDS(self, DS ds):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ds));
  __pyx_r = ((PyObject *)__pyx_v_ds);
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":635
 *         CHKERR( NEPSetRG(self.nep, rg.rg) )
 * 
 *     def getDS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the direct solver associated to the eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ds);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":649
 *         return ds
 * 
 *     def setDS(self, DS ds):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a direct solver object to the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_67setDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_66setDS[] = "NEP.setDS(self, DS ds)\n\n        Associates a direct solver object to the eigensolver.\n\n        Parameters\n        ----------\n        ds: DS\n            The direct solver context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_67setDS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcDSObject *__pyx_v_ds = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setDS (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ds,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ds)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setDS") < 0)) __PYX_ERR(20, 649, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_ds = ((struct PySlepcDSObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setDS", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 649, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ds), __pyx_ptype_8slepc4py_5SLEPc_DS, 0, "ds", 0))) __PYX_ERR(20, 649, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_66setDS(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_ds);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_66setDS(struct PySlepcNEPObject *__pyx_v_self, struct PySlepcDSObject *__pyx_v_ds) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setDS", 0);

  /* "SLEPc/NEP.pyx":658
 *             The direct solver context.
 *         """
 *         CHKERR( NEPSetDS(self.nep, ds.ds) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetDS(__pyx_v_self->nep, __pyx_v_ds->ds)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 658, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":649
 *         return ds
 * 
 *     def setDS(self, DS ds):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a direct solver object to the eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":662
 *     #
 * 
 *     def setInitialSpace(self, space):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the initial space from which the eigensolver starts to
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_69setInitialSpace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_68setInitialSpace[] = "NEP.setInitialSpace(self, space)\n\n        Sets the initial space from which the eigensolver starts to\n        iterate.\n\n        Parameters\n        ----------\n        space: Vec or sequence of Vec\n           The initial space\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_69setInitialSpace(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_space = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setInitialSpace (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_space,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_space)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setInitialSpace") < 0)) __PYX_ERR(20, 662, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_space = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setInitialSpace", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 662, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setInitialSpace", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_68setInitialSpace(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_space);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_68setInitialSpace(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_space) {
  Vec *__pyx_v_vs;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_ns;
  CYTHON_UNUSED PyObject *__pyx_v_tmp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  Py_ssize_t __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  Py_ssize_t __pyx_t_6;
  Vec __pyx_t_7;
  int __pyx_t_8;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setInitialSpace", 0);
  __Pyx_INCREF(__pyx_v_space);

  /* "SLEPc/NEP.pyx":672
 *            The initial space
 *         """
 *         if isinstance(space, Vec): space = [space]             # <<<<<<<<<<<<<<
 *         cdef PetscVec *vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)
 */
  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_space, __pyx_ptype_8petsc4py_5PETSc_Vec); 
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 672, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_space);
    __Pyx_GIVEREF(__pyx_v_space);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_space);
    __Pyx_DECREF_SET(__pyx_v_space, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/NEP.pyx":673
 *         """
 *         if isinstance(space, Vec): space = [space]
 *         cdef PetscVec *vs = NULL             # <<<<<<<<<<<<<<
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 */
  __pyx_v_vs = NULL;

  /* "SLEPc/NEP.pyx":674
 *         if isinstance(space, Vec): space = [space]
 *         cdef PetscVec *vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)             # <<<<<<<<<<<<<<
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 */
  __pyx_v_i = 0;
  __pyx_t_4 = PyObject_Length(__pyx_v_space); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(20, 674, __pyx_L1_error)
  __pyx_v_ns = __pyx_t_4;

  /* "SLEPc/NEP.pyx":675
 *         cdef PetscVec *vs = NULL
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)             # <<<<<<<<<<<<<<
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 *         CHKERR( NEPSetInitialSpace(self.nep, <PetscInt>ns, vs) )
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_ns) * (sizeof(Vec))), ((void **)(&__pyx_v_vs))); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 675, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/NEP.pyx":676
 *         cdef Py_ssize_t i = 0, ns = len(space)
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSetInitialSpace(self.nep, <PetscInt>ns, vs) )
 * 
 */
  __pyx_t_4 = __pyx_v_ns;
  __pyx_t_5 = __pyx_t_4;
  for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
    __pyx_v_i = __pyx_t_6;
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_space, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 676, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8petsc4py_5PETSc_Vec)))) __PYX_ERR(20, 676, __pyx_L1_error)
    __pyx_t_7 = ((struct PyPetscVecObject *)__pyx_t_3)->vec;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    (__pyx_v_vs[__pyx_v_i]) = __pyx_t_7;
  }

  /* "SLEPc/NEP.pyx":677
 *         cdef tmp = allocate(<size_t>ns*sizeof(PetscVec),<void**>&vs)
 *         for i in range(ns): vs[i] = (<Vec?>space[i]).vec
 *         CHKERR( NEPSetInitialSpace(self.nep, <PetscInt>ns, vs) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_8 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetInitialSpace(__pyx_v_self->nep, ((PetscInt)__pyx_v_ns), __pyx_v_vs)); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(20, 677, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":662
 *     #
 * 
 *     def setInitialSpace(self, space):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the initial space from which the eigensolver starts to
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setInitialSpace", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp);
  __Pyx_XDECREF(__pyx_v_space);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":681
 *     #
 * 
 *     def setStoppingTest(self, stopping, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_71setStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_70setStoppingTest[] = "NEP.setStoppingTest(self, stopping, args=None, kargs=None)\n\n        Sets a function to decide when to stop the outer iteration of the eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_71setStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_stopping = 0;
  PyObject *__pyx_v_args = 0;
  PyObject *__pyx_v_kargs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setStoppingTest (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_stopping,&__pyx_n_s_args,&__pyx_n_s_kargs,0};
    PyObject* values[3] = {0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_stopping)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kargs);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setStoppingTest") < 0)) __PYX_ERR(20, 681, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_stopping = values[0];
    __pyx_v_args = values[1];
    __pyx_v_kargs = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setStoppingTest", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 681, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setStoppingTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_70setStoppingTest(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_stopping, __pyx_v_args, __pyx_v_kargs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_70setStoppingTest(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_stopping, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setStoppingTest", 0);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);

  /* "SLEPc/NEP.pyx":685
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 *         """
 *         if stopping is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
  __pyx_t_1 = (__pyx_v_stopping != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "SLEPc/NEP.pyx":686
 *         """
 *         if stopping is not None:
 *             if args is None: args = ()             # <<<<<<<<<<<<<<
 *             if kargs is None: kargs = {}
 *             self.set_attr('__stopping__', (stopping, args, kargs))
 */
    __pyx_t_2 = (__pyx_v_args == Py_None);
    __pyx_t_1 = (__pyx_t_2 != 0);
    if (__pyx_t_1) {
      __Pyx_INCREF(__pyx_empty_tuple);
      __Pyx_DECREF_SET(__pyx_v_args, __pyx_empty_tuple);
    }

    /* "SLEPc/NEP.pyx":687
 *         if stopping is not None:
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}             # <<<<<<<<<<<<<<
 *             self.set_attr('__stopping__', (stopping, args, kargs))
 *             CHKERR( NEPSetStoppingTestFunction(self.nep, NEP_Stopping, NULL, NULL) )
 */
    __pyx_t_1 = (__pyx_v_kargs == Py_None);
    __pyx_t_2 = (__pyx_t_1 != 0);
    if (__pyx_t_2) {
      __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 687, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF_SET(__pyx_v_kargs, __pyx_t_3);
      __pyx_t_3 = 0;
    }

    /* "SLEPc/NEP.pyx":688
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 *             self.set_attr('__stopping__', (stopping, args, kargs))             # <<<<<<<<<<<<<<
 *             CHKERR( NEPSetStoppingTestFunction(self.nep, NEP_Stopping, NULL, NULL) )
 *         else:
 */
    __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 688, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_stopping);
    __Pyx_GIVEREF(__pyx_v_stopping);
    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_stopping);
    __Pyx_INCREF(__pyx_v_args);
    __Pyx_GIVEREF(__pyx_v_args);
    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_args);
    __Pyx_INCREF(__pyx_v_kargs);
    __Pyx_GIVEREF(__pyx_v_kargs);
    PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_kargs);
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__stopping__"), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 688, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "SLEPc/NEP.pyx":689
 *             if kargs is None: kargs = {}
 *             self.set_attr('__stopping__', (stopping, args, kargs))
 *             CHKERR( NEPSetStoppingTestFunction(self.nep, NEP_Stopping, NULL, NULL) )             # <<<<<<<<<<<<<<
 *         else:
 *             self.set_attr('__stopping__', None)
 */
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetStoppingTestFunction(__pyx_v_self->nep, __pyx_f_8slepc4py_5SLEPc_NEP_Stopping, NULL, NULL)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(20, 689, __pyx_L1_error)

    /* "SLEPc/NEP.pyx":685
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 *         """
 *         if stopping is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
    goto __pyx_L3;
  }

  /* "SLEPc/NEP.pyx":691
 *             CHKERR( NEPSetStoppingTestFunction(self.nep, NEP_Stopping, NULL, NULL) )
 *         else:
 *             self.set_attr('__stopping__', None)             # <<<<<<<<<<<<<<
 *             CHKERR( NEPSetStoppingTestFunction(self.nep, NEPStoppingBasic, NULL, NULL) )
 * 
 */
  /*else*/ {
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__stopping__"), Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 691, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "SLEPc/NEP.pyx":692
 *         else:
 *             self.set_attr('__stopping__', None)
 *             CHKERR( NEPSetStoppingTestFunction(self.nep, NEPStoppingBasic, NULL, NULL) )             # <<<<<<<<<<<<<<
 * 
 *     def getStoppingTest(self):
 */
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetStoppingTestFunction(__pyx_v_self->nep, NEPStoppingBasic, NULL, NULL)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(20, 692, __pyx_L1_error)
  }
  __pyx_L3:;

  /* "SLEPc/NEP.pyx":681
 *     #
 * 
 *     def setStoppingTest(self, stopping, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a function to decide when to stop the outer iteration of the eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setStoppingTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":694
 *             CHKERR( NEPSetStoppingTestFunction(self.nep, NEPStoppingBasic, NULL, NULL) )
 * 
 *     def getStoppingTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the stopping function.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_73getStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_72getStoppingTest[] = "NEP.getStoppingTest(self)\n\n        Gets the stopping function.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_73getStoppingTest(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getStoppingTest (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getStoppingTest", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getStoppingTest", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_72getStoppingTest(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_72getStoppingTest(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getStoppingTest", 0);

  /* "SLEPc/NEP.pyx":698
 *         Gets the stopping function.
 *         """
 *         return self.get_attr('__stopping__')             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__stopping__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 698, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":694
 *             CHKERR( NEPSetStoppingTestFunction(self.nep, NEPStoppingBasic, NULL, NULL) )
 * 
 *     def getStoppingTest(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the stopping function.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getStoppingTest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":702
 *     #
 * 
 *     def setMonitor(self, monitor, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Appends a monitor function to the list of monitors.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_75setMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_74setMonitor[] = "NEP.setMonitor(self, monitor, args=None, kargs=None)\n\n        Appends a monitor function to the list of monitors.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_75setMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_monitor = 0;
  PyObject *__pyx_v_args = 0;
  PyObject *__pyx_v_kargs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setMonitor (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_monitor,&__pyx_n_s_args,&__pyx_n_s_kargs,0};
    PyObject* values[3] = {0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_monitor)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kargs);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setMonitor") < 0)) __PYX_ERR(20, 702, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_monitor = values[0];
    __pyx_v_args = values[1];
    __pyx_v_kargs = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setMonitor", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 702, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_74setMonitor(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_monitor, __pyx_v_args, __pyx_v_kargs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_74setMonitor(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_monitor, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs) {
  PyObject *__pyx_v_monitorlist = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setMonitor", 0);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);

  /* "SLEPc/NEP.pyx":706
 *         Appends a monitor function to the list of monitors.
 *         """
 *         if monitor is None: return             # <<<<<<<<<<<<<<
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:
 */
  __pyx_t_1 = (__pyx_v_monitor == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;
  }

  /* "SLEPc/NEP.pyx":707
 *         """
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 *         if monitorlist is None:
 *             monitorlist = []
 */
  __pyx_t_3 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__")); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 707, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_monitorlist = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/NEP.pyx":708
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:             # <<<<<<<<<<<<<<
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 */
  __pyx_t_2 = (__pyx_v_monitorlist == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {

    /* "SLEPc/NEP.pyx":709
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:
 *             monitorlist = []             # <<<<<<<<<<<<<<
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( NEPMonitorSet(self.nep, NEP_Monitor, NULL, NULL) )
 */
    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 709, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_monitorlist, __pyx_t_3);
    __pyx_t_3 = 0;

    /* "SLEPc/NEP.pyx":710
 *         if monitorlist is None:
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)             # <<<<<<<<<<<<<<
 *             CHKERR( NEPMonitorSet(self.nep, NEP_Monitor, NULL, NULL) )
 *         if args is None: args = ()
 */
    __pyx_t_3 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__"), __pyx_v_monitorlist); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 710, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

    /* "SLEPc/NEP.pyx":711
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( NEPMonitorSet(self.nep, NEP_Monitor, NULL, NULL) )             # <<<<<<<<<<<<<<
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPMonitorSet(__pyx_v_self->nep, __pyx_f_8slepc4py_5SLEPc_NEP_Monitor, NULL, NULL)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(20, 711, __pyx_L1_error)

    /* "SLEPc/NEP.pyx":708
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:             # <<<<<<<<<<<<<<
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 */
  }

  /* "SLEPc/NEP.pyx":712
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( NEPMonitorSet(self.nep, NEP_Monitor, NULL, NULL) )
 *         if args is None: args = ()             # <<<<<<<<<<<<<<
 *         if kargs is None: kargs = {}
 *         monitorlist.append((monitor, args, kargs))
 */
  __pyx_t_1 = (__pyx_v_args == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __Pyx_INCREF(__pyx_empty_tuple);
    __Pyx_DECREF_SET(__pyx_v_args, __pyx_empty_tuple);
  }

  /* "SLEPc/NEP.pyx":713
 *             CHKERR( NEPMonitorSet(self.nep, NEP_Monitor, NULL, NULL) )
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}             # <<<<<<<<<<<<<<
 *         monitorlist.append((monitor, args, kargs))
 * 
 */
  __pyx_t_2 = (__pyx_v_kargs == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 713, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_kargs, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/NEP.pyx":714
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}
 *         monitorlist.append((monitor, args, kargs))             # <<<<<<<<<<<<<<
 * 
 *     def getMonitor(self):
 */
  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 714, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_monitor);
  __Pyx_GIVEREF(__pyx_v_monitor);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_monitor);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_GIVEREF(__pyx_v_args);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);
  __Pyx_GIVEREF(__pyx_v_kargs);
  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_kargs);
  __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_monitorlist, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(20, 714, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/NEP.pyx":702
 *     #
 * 
 *     def setMonitor(self, monitor, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Appends a monitor function to the list of monitors.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_monitorlist);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":716
 *         monitorlist.append((monitor, args, kargs))
 * 
 *     def getMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the list of monitor functions.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_77getMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_76getMonitor[] = "NEP.getMonitor(self)\n\n        Gets the list of monitor functions.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_77getMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getMonitor (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getMonitor", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getMonitor", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_76getMonitor(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_76getMonitor(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getMonitor", 0);

  /* "SLEPc/NEP.pyx":720
 *         Gets the list of monitor functions.
 *         """
 *         return self.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 * 
 *     def cancelMonitor(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 720, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":716
 *         monitorlist.append((monitor, args, kargs))
 * 
 *     def getMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the list of monitor functions.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":722
 *         return self.get_attr('__monitor__')
 * 
 *     def cancelMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Clears all monitors for a `NEP` object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_79cancelMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_78cancelMonitor[] = "NEP.cancelMonitor(self)\n\n        Clears all monitors for a `NEP` object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_79cancelMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("cancelMonitor (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("cancelMonitor", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "cancelMonitor", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_78cancelMonitor(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_78cancelMonitor(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("cancelMonitor", 0);

  /* "SLEPc/NEP.pyx":726
 *         Clears all monitors for a `NEP` object.
 *         """
 *         CHKERR( NEPMonitorCancel(self.nep) )             # <<<<<<<<<<<<<<
 *         self.set_attr('__monitor__', None)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPMonitorCancel(__pyx_v_self->nep)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 726, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":727
 *         """
 *         CHKERR( NEPMonitorCancel(self.nep) )
 *         self.set_attr('__monitor__', None)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_2 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__"), Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 727, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/NEP.pyx":722
 *         return self.get_attr('__monitor__')
 * 
 *     def cancelMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Clears all monitors for a `NEP` object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.cancelMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":731
 *     #
 * 
 *     def setUp(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets up all the internal data structures necessary for the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_81setUp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_80setUp[] = "NEP.setUp(self)\n\n        Sets up all the internal data structures necessary for the\n        execution of the eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_81setUp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setUp (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setUp", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setUp", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_80setUp(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_80setUp(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setUp", 0);

  /* "SLEPc/NEP.pyx":736
 *         execution of the eigensolver.
 *         """
 *         CHKERR( NEPSetUp(self.nep) )             # <<<<<<<<<<<<<<
 * 
 *     def solve(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetUp(__pyx_v_self->nep)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 736, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":731
 *     #
 * 
 *     def setUp(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets up all the internal data structures necessary for the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setUp", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":738
 *         CHKERR( NEPSetUp(self.nep) )
 * 
 *     def solve(self):             # <<<<<<<<<<<<<<
 *         """
 *         Solves the eigensystem.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_83solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_82solve[] = "NEP.solve(self)\n\n        Solves the eigensystem.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_83solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("solve (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("solve", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "solve", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_82solve(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_82solve(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("solve", 0);

  /* "SLEPc/NEP.pyx":742
 *         Solves the eigensystem.
 *         """
 *         CHKERR( NEPSolve(self.nep) )             # <<<<<<<<<<<<<<
 * 
 *     def getIterationNumber(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSolve(__pyx_v_self->nep)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 742, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":738
 *         CHKERR( NEPSetUp(self.nep) )
 * 
 *     def solve(self):             # <<<<<<<<<<<<<<
 *         """
 *         Solves the eigensystem.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.solve", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":744
 *         CHKERR( NEPSolve(self.nep) )
 * 
 *     def getIterationNumber(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the current iteration number. If the call to `solve()` is
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_85getIterationNumber(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_84getIterationNumber[] = "NEP.getIterationNumber(self)\n\n        Gets the current iteration number. If the call to `solve()` is\n        complete, then it returns the number of iterations carried out\n        by the solution method.\n\n        Returns\n        -------\n        its: int\n             Iteration number.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_85getIterationNumber(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getIterationNumber (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getIterationNumber", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getIterationNumber", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_84getIterationNumber(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_84getIterationNumber(struct PySlepcNEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getIterationNumber", 0);

  /* "SLEPc/NEP.pyx":755
 *              Iteration number.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetIterationNumber(self.nep, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/NEP.pyx":756
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( NEPGetIterationNumber(self.nep, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetIterationNumber(__pyx_v_self->nep, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 756, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":757
 *         cdef PetscInt ival = 0
 *         CHKERR( NEPGetIterationNumber(self.nep, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def getConvergedReason(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 757, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":744
 *         CHKERR( NEPSolve(self.nep) )
 * 
 *     def getIterationNumber(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the current iteration number. If the call to `solve()` is
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getIterationNumber", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":759
 *         return toInt(ival)
 * 
 *     def getConvergedReason(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the reason why the `solve()` iteration was stopped.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_87getConvergedReason(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_86getConvergedReason[] = "NEP.getConvergedReason(self)\n\n        Gets the reason why the `solve()` iteration was stopped.\n\n        Returns\n        -------\n        reason: `NEP.ConvergedReason` enumerate\n            Negative value indicates diverged, positive value\n            converged.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_87getConvergedReason(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getConvergedReason (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getConvergedReason", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConvergedReason", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_86getConvergedReason(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_86getConvergedReason(struct PySlepcNEPObject *__pyx_v_self) {
  NEPConvergedReason __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getConvergedReason", 0);

  /* "SLEPc/NEP.pyx":769
 *             converged.
 *         """
 *         cdef SlepcNEPConvergedReason val = NEP_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetConvergedReason(self.nep, &val) )
 *         return val
 */
  __pyx_v_val = NEP_CONVERGED_ITERATING;

  /* "SLEPc/NEP.pyx":770
 *         """
 *         cdef SlepcNEPConvergedReason val = NEP_CONVERGED_ITERATING
 *         CHKERR( NEPGetConvergedReason(self.nep, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetConvergedReason(__pyx_v_self->nep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 770, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":771
 *         cdef SlepcNEPConvergedReason val = NEP_CONVERGED_ITERATING
 *         CHKERR( NEPGetConvergedReason(self.nep, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def getConverged(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_NEPConvergedReason(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 771, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":759
 *         return toInt(ival)
 * 
 *     def getConvergedReason(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the reason why the `solve()` iteration was stopped.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getConvergedReason", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":773
 *         return val
 * 
 *     def getConverged(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of converged eigenpairs.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_89getConverged(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_88getConverged[] = "NEP.getConverged(self)\n\n        Gets the number of converged eigenpairs.\n\n        Returns\n        -------\n        nconv: int\n            Number of converged eigenpairs.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_89getConverged(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getConverged (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getConverged", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConverged", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_88getConverged(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_88getConverged(struct PySlepcNEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getConverged", 0);

  /* "SLEPc/NEP.pyx":782
 *             Number of converged eigenpairs.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetConverged(self.nep, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/NEP.pyx":783
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( NEPGetConverged(self.nep, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetConverged(__pyx_v_self->nep, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 783, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":784
 *         cdef PetscInt ival = 0
 *         CHKERR( NEPGetConverged(self.nep, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def getEigenpair(self, int i, Vec Vr=None, Vec Vi=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 784, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":773
 *         return val
 * 
 *     def getConverged(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the number of converged eigenpairs.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getConverged", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":786
 *         return toInt(ival)
 * 
 *     def getEigenpair(self, int i, Vec Vr=None, Vec Vi=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th solution of the eigenproblem as computed by
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_91getEigenpair(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_90getEigenpair[] = "NEP.getEigenpair(self, int i, Vec Vr=None, Vec Vi=None)\n\n        Gets the i-th solution of the eigenproblem as computed by\n        `solve()`.  The solution consists of both the eigenvalue and\n        the eigenvector.\n\n        Parameters\n        ----------\n        i: int\n            Index of the solution to be obtained.\n        Vr: Vec, optional\n            Placeholder for the returned eigenvector (real part).\n        Vi: Vec, optional\n            Placeholder for the returned eigenvector (imaginary part).\n\n        Returns\n        -------\n        e: scalar (possibly complex)\n            The computed eigenvalue.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_91getEigenpair(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  struct PyPetscVecObject *__pyx_v_Vr = 0;
  struct PyPetscVecObject *__pyx_v_Vi = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getEigenpair (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,&__pyx_n_s_Vr,&__pyx_n_s_Vi,0};
    PyObject* values[3] = {0,0,0};
    values[1] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    values[2] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Vr);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Vi);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getEigenpair") < 0)) __PYX_ERR(20, 786, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(20, 786, __pyx_L3_error)
    __pyx_v_Vr = ((struct PyPetscVecObject *)values[1]);
    __pyx_v_Vi = ((struct PyPetscVecObject *)values[2]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getEigenpair", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 786, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getEigenpair", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Vr), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "Vr", 0))) __PYX_ERR(20, 786, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Vi), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "Vi", 0))) __PYX_ERR(20, 786, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_90getEigenpair(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_i, __pyx_v_Vr, __pyx_v_Vi);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_90getEigenpair(struct PySlepcNEPObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_Vr, struct PyPetscVecObject *__pyx_v_Vi) {
  PetscScalar __pyx_v_sval1;
  PetscScalar __pyx_v_sval2;
  Vec __pyx_v_vecr;
  Vec __pyx_v_veci;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Vec __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getEigenpair", 0);

  /* "SLEPc/NEP.pyx":806
 *             The computed eigenvalue.
 *         """
 *         cdef PetscScalar sval1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar sval2 = 0
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL
 */
  __pyx_v_sval1 = 0.0;

  /* "SLEPc/NEP.pyx":807
 *         """
 *         cdef PetscScalar sval1 = 0
 *         cdef PetscScalar sval2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL
 */
  __pyx_v_sval2 = 0.0;

  /* "SLEPc/NEP.pyx":808
 *         cdef PetscScalar sval1 = 0
 *         cdef PetscScalar sval2 = 0
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL             # <<<<<<<<<<<<<<
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL
 *         CHKERR( NEPGetEigenpair(self.nep, i, &sval1, &sval2, vecr, veci) )
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_Vr) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_Vr->vec;
  } else {
    __pyx_t_1 = ((Vec)NULL);
  }
  __pyx_v_vecr = __pyx_t_1;

  /* "SLEPc/NEP.pyx":809
 *         cdef PetscScalar sval2 = 0
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetEigenpair(self.nep, i, &sval1, &sval2, vecr, veci) )
 *         return toComplex(sval1, sval2)
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_Vi) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_Vi->vec;
  } else {
    __pyx_t_1 = ((Vec)NULL);
  }
  __pyx_v_veci = __pyx_t_1;

  /* "SLEPc/NEP.pyx":810
 *         cdef PetscVec vecr = Vr.vec if Vr is not None else <PetscVec>NULL
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL
 *         CHKERR( NEPGetEigenpair(self.nep, i, &sval1, &sval2, vecr, veci) )             # <<<<<<<<<<<<<<
 *         return toComplex(sval1, sval2)
 * 
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetEigenpair(__pyx_v_self->nep, __pyx_v_i, (&__pyx_v_sval1), (&__pyx_v_sval2), __pyx_v_vecr, __pyx_v_veci)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(20, 810, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":811
 *         cdef PetscVec veci = Vi.vec if Vi is not None else <PetscVec>NULL
 *         CHKERR( NEPGetEigenpair(self.nep, i, &sval1, &sval2, vecr, veci) )
 *         return toComplex(sval1, sval2)             # <<<<<<<<<<<<<<
 * 
 *     def getLeftEigenvector(self, int i, Vec Wr, Vec Wi=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toComplex(__pyx_v_sval1, __pyx_v_sval2); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 811, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":786
 *         return toInt(ival)
 * 
 *     def getEigenpair(self, int i, Vec Vr=None, Vec Vi=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th solution of the eigenproblem as computed by
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getEigenpair", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":813
 *         return toComplex(sval1, sval2)
 * 
 *     def getLeftEigenvector(self, int i, Vec Wr, Vec Wi=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th left eigenvector as computed by `solve()`.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_93getLeftEigenvector(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_92getLeftEigenvector[] = "NEP.getLeftEigenvector(self, int i, Vec Wr, Vec Wi=None)\n\n        Gets the i-th left eigenvector as computed by `solve()`.\n\n        Parameters\n        ----------\n        i: int\n           Index of the solution to be obtained.\n        Wr: Vec\n            Placeholder for the returned eigenvector (real part).\n        Wi: Vec, optional\n            Placeholder for the returned eigenvector (imaginary part).\n\n        Notes\n        -----\n        The index ``i`` should be a value between ``0`` and\n        ``nconv-1`` (see `getConverged()`). Eigensolutions are indexed\n        according to the ordering criterion established with\n        `setWhichEigenpairs()`.\n\n        Left eigenvectors are available only if the twosided flag was set\n        with `setTwoSided()`.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_93getLeftEigenvector(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  struct PyPetscVecObject *__pyx_v_Wr = 0;
  struct PyPetscVecObject *__pyx_v_Wi = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getLeftEigenvector (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,&__pyx_n_s_Wr,&__pyx_n_s_Wi,0};
    PyObject* values[3] = {0,0,0};
    values[2] = (PyObject *)((struct PyPetscVecObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Wr)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("getLeftEigenvector", 0, 2, 3, 1); __PYX_ERR(20, 813, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Wi);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getLeftEigenvector") < 0)) __PYX_ERR(20, 813, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(20, 813, __pyx_L3_error)
    __pyx_v_Wr = ((struct PyPetscVecObject *)values[1]);
    __pyx_v_Wi = ((struct PyPetscVecObject *)values[2]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getLeftEigenvector", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 813, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getLeftEigenvector", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Wr), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "Wr", 0))) __PYX_ERR(20, 813, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_Wi), __pyx_ptype_8petsc4py_5PETSc_Vec, 1, "Wi", 0))) __PYX_ERR(20, 813, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_92getLeftEigenvector(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_i, __pyx_v_Wr, __pyx_v_Wi);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_92getLeftEigenvector(struct PySlepcNEPObject *__pyx_v_self, int __pyx_v_i, struct PyPetscVecObject *__pyx_v_Wr, struct PyPetscVecObject *__pyx_v_Wi) {
  Vec __pyx_v_vecr;
  Vec __pyx_v_veci;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Vec __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getLeftEigenvector", 0);

  /* "SLEPc/NEP.pyx":836
 *         with `setTwoSided()`.
 *         """
 *         cdef PetscVec vecr = Wr.vec             # <<<<<<<<<<<<<<
 *         cdef PetscVec veci = Wi.vec if Wi is not None else <PetscVec>NULL
 *         CHKERR( NEPGetLeftEigenvector(self.nep, i, vecr, veci) )
 */
  __pyx_t_1 = __pyx_v_Wr->vec;
  __pyx_v_vecr = __pyx_t_1;

  /* "SLEPc/NEP.pyx":837
 *         """
 *         cdef PetscVec vecr = Wr.vec
 *         cdef PetscVec veci = Wi.vec if Wi is not None else <PetscVec>NULL             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetLeftEigenvector(self.nep, i, vecr, veci) )
 * 
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_Wi) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_Wi->vec;
  } else {
    __pyx_t_1 = ((Vec)NULL);
  }
  __pyx_v_veci = __pyx_t_1;

  /* "SLEPc/NEP.pyx":838
 *         cdef PetscVec vecr = Wr.vec
 *         cdef PetscVec veci = Wi.vec if Wi is not None else <PetscVec>NULL
 *         CHKERR( NEPGetLeftEigenvector(self.nep, i, vecr, veci) )             # <<<<<<<<<<<<<<
 * 
 *     def getErrorEstimate(self, int i):
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetLeftEigenvector(__pyx_v_self->nep, __pyx_v_i, __pyx_v_vecr, __pyx_v_veci)); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(20, 838, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":813
 *         return toComplex(sval1, sval2)
 * 
 *     def getLeftEigenvector(self, int i, Vec Wr, Vec Wi=None):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the i-th left eigenvector as computed by `solve()`.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getLeftEigenvector", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":840
 *         CHKERR( NEPGetLeftEigenvector(self.nep, i, vecr, veci) )
 * 
 *     def getErrorEstimate(self, int i):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the error estimate associated to the i-th computed
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_95getErrorEstimate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_94getErrorEstimate[] = "NEP.getErrorEstimate(self, int i)\n\n        Returns the error estimate associated to the i-th computed\n        eigenpair.\n\n        Parameters\n        ----------\n        i: int\n            Index of the solution to be considered.\n\n        Returns\n        -------\n        error: real\n            Error estimate.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_95getErrorEstimate(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getErrorEstimate (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getErrorEstimate") < 0)) __PYX_ERR(20, 840, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(20, 840, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("getErrorEstimate", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 840, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getErrorEstimate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_94getErrorEstimate(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_i);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_94getErrorEstimate(struct PySlepcNEPObject *__pyx_v_self, int __pyx_v_i) {
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getErrorEstimate", 0);

  /* "SLEPc/NEP.pyx":855
 *             Error estimate.
 *         """
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetErrorEstimate(self.nep, i, &rval) )
 *         return toReal(rval)
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/NEP.pyx":856
 *         """
 *         cdef PetscReal rval = 0
 *         CHKERR( NEPGetErrorEstimate(self.nep, i, &rval) )             # <<<<<<<<<<<<<<
 *         return toReal(rval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetErrorEstimate(__pyx_v_self->nep, __pyx_v_i, (&__pyx_v_rval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 856, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":857
 *         cdef PetscReal rval = 0
 *         CHKERR( NEPGetErrorEstimate(self.nep, i, &rval) )
 *         return toReal(rval)             # <<<<<<<<<<<<<<
 * 
 *     def computeError(self, int i, etype=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 857, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":840
 *         CHKERR( NEPGetLeftEigenvector(self.nep, i, vecr, veci) )
 * 
 *     def getErrorEstimate(self, int i):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the error estimate associated to the i-th computed
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getErrorEstimate", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":859
 *         return toReal(rval)
 * 
 *     def computeError(self, int i, etype=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the error (based on the residual norm) associated with the i-th
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_97computeError(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_96computeError[] = "NEP.computeError(self, int i, etype=None)\n\n        Computes the error (based on the residual norm) associated with the i-th\n        computed eigenpair.\n\n        Parameters\n        ----------\n        i: int\n            Index of the solution to be considered.\n        etype: `NEP.ErrorType` enumerate\n            The error type to compute.\n\n        Returns\n        -------\n        error: real\n            The error bound, computed in various ways from the residual norm\n            ``||T(lambda)x||_2`` where ``lambda`` is the eigenvalue and\n            ``x`` is the eigenvector.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_97computeError(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_v_i;
  PyObject *__pyx_v_etype = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("computeError (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_i,&__pyx_n_s_etype,0};
    PyObject* values[2] = {0,0};
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_i)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_etype);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "computeError") < 0)) __PYX_ERR(20, 859, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_i = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(20, 859, __pyx_L3_error)
    __pyx_v_etype = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("computeError", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 859, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.computeError", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_96computeError(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_i, __pyx_v_etype);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_96computeError(struct PySlepcNEPObject *__pyx_v_self, int __pyx_v_i, PyObject *__pyx_v_etype) {
  NEPErrorType __pyx_v_et;
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  NEPErrorType __pyx_t_3;
  int __pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("computeError", 0);

  /* "SLEPc/NEP.pyx":878
 *             ``x`` is the eigenvector.
 *         """
 *         cdef SlepcNEPErrorType et = NEP_ERROR_RELATIVE             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval = 0
 *         if etype is not None: et = etype
 */
  __pyx_v_et = NEP_ERROR_RELATIVE;

  /* "SLEPc/NEP.pyx":879
 *         """
 *         cdef SlepcNEPErrorType et = NEP_ERROR_RELATIVE
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         if etype is not None: et = etype
 *         CHKERR( NEPComputeError(self.nep, i, et, &rval) )
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/NEP.pyx":880
 *         cdef SlepcNEPErrorType et = NEP_ERROR_RELATIVE
 *         cdef PetscReal rval = 0
 *         if etype is not None: et = etype             # <<<<<<<<<<<<<<
 *         CHKERR( NEPComputeError(self.nep, i, et, &rval) )
 *         return toReal(rval)
 */
  __pyx_t_1 = (__pyx_v_etype != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = ((NEPErrorType)__Pyx_PyInt_As_NEPErrorType(__pyx_v_etype)); if (unlikely(PyErr_Occurred())) __PYX_ERR(20, 880, __pyx_L1_error)
    __pyx_v_et = __pyx_t_3;
  }

  /* "SLEPc/NEP.pyx":881
 *         cdef PetscReal rval = 0
 *         if etype is not None: et = etype
 *         CHKERR( NEPComputeError(self.nep, i, et, &rval) )             # <<<<<<<<<<<<<<
 *         return toReal(rval)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPComputeError(__pyx_v_self->nep, __pyx_v_i, __pyx_v_et, (&__pyx_v_rval))); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(20, 881, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":882
 *         if etype is not None: et = etype
 *         CHKERR( NEPComputeError(self.nep, i, et, &rval) )
 *         return toReal(rval)             # <<<<<<<<<<<<<<
 * 
 *     def errorView(self, etype=None, Viewer viewer=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 882, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_r = __pyx_t_5;
  __pyx_t_5 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":859
 *         return toReal(rval)
 * 
 *     def computeError(self, int i, etype=None):             # <<<<<<<<<<<<<<
 *         """
 *         Computes the error (based on the residual norm) associated with the i-th
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.computeError", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":884
 *         return toReal(rval)
 * 
 *     def errorView(self, etype=None, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the errors associated with the computed solution
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_99errorView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_98errorView[] = "NEP.errorView(self, etype=None, Viewer viewer=None)\n\n        Displays the errors associated with the computed solution\n        (as well as the eigenvalues).\n\n        Parameters\n        ----------\n        etype: `NEP.ErrorType` enumerate, optional\n           The error type to compute.\n        viewer: Viewer, optional.\n                Visualization context; if not provided, the standard\n                output is used.\n\n        Notes\n        -----\n        By default, this function checks the error of all eigenpairs and prints\n        the eigenvalues if all of them are below the requested tolerance.\n        If the viewer has format ``ASCII_INFO_DETAIL`` then a table with\n        eigenvalues and corresponding errors is printed.\n\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_99errorView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_etype = 0;
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("errorView (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_etype,&__pyx_n_s_viewer,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_etype);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "errorView") < 0)) __PYX_ERR(20, 884, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_etype = values[0];
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("errorView", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 884, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.errorView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(20, 884, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_98errorView(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_etype, __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_98errorView(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_etype, struct PyPetscViewerObject *__pyx_v_viewer) {
  NEPErrorType __pyx_v_et;
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  NEPErrorType __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("errorView", 0);

  /* "SLEPc/NEP.pyx":905
 * 
 *         """
 *         cdef SlepcNEPErrorType et = NEP_ERROR_RELATIVE             # <<<<<<<<<<<<<<
 *         if etype is not None: et = etype
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 */
  __pyx_v_et = NEP_ERROR_RELATIVE;

  /* "SLEPc/NEP.pyx":906
 *         """
 *         cdef SlepcNEPErrorType et = NEP_ERROR_RELATIVE
 *         if etype is not None: et = etype             # <<<<<<<<<<<<<<
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( NEPErrorView(self.nep, et, vwr) )
 */
  __pyx_t_1 = (__pyx_v_etype != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = ((NEPErrorType)__Pyx_PyInt_As_NEPErrorType(__pyx_v_etype)); if (unlikely(PyErr_Occurred())) __PYX_ERR(20, 906, __pyx_L1_error)
    __pyx_v_et = __pyx_t_3;
  }

  /* "SLEPc/NEP.pyx":907
 *         cdef SlepcNEPErrorType et = NEP_ERROR_RELATIVE
 *         if etype is not None: et = etype
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPErrorView(self.nep, et, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/NEP.pyx":908
 *         if etype is not None: et = etype
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( NEPErrorView(self.nep, et, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def valuesView(self, Viewer viewer=None):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPErrorView(__pyx_v_self->nep, __pyx_v_et, __pyx_v_vwr)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(20, 908, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":884
 *         return toReal(rval)
 * 
 *     def errorView(self, etype=None, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the errors associated with the computed solution
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.errorView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":910
 *         CHKERR( NEPErrorView(self.nep, et, vwr) )
 * 
 *     def valuesView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the computed eigenvalues in a viewer.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_101valuesView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_100valuesView[] = "NEP.valuesView(self, Viewer viewer=None)\n\n        Displays the computed eigenvalues in a viewer.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional.\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_101valuesView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("valuesView (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "valuesView") < 0)) __PYX_ERR(20, 910, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("valuesView", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 910, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.valuesView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(20, 910, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_100valuesView(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_100valuesView(struct PySlepcNEPObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("valuesView", 0);

  /* "SLEPc/NEP.pyx":920
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPValuesView(self.nep, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/NEP.pyx":921
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( NEPValuesView(self.nep, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def vectorsView(self, Viewer viewer=None):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPValuesView(__pyx_v_self->nep, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 921, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":910
 *         CHKERR( NEPErrorView(self.nep, et, vwr) )
 * 
 *     def valuesView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Displays the computed eigenvalues in a viewer.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.valuesView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":923
 *         CHKERR( NEPValuesView(self.nep, vwr) )
 * 
 *     def vectorsView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Outputs computed eigenvectors to a viewer.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_103vectorsView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_102vectorsView[] = "NEP.vectorsView(self, Viewer viewer=None)\n\n        Outputs computed eigenvectors to a viewer.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional.\n                Visualization context; if not provided, the standard\n                output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_103vectorsView(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("vectorsView (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "vectorsView") < 0)) __PYX_ERR(20, 923, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("vectorsView", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 923, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.vectorsView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(20, 923, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_102vectorsView(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_102vectorsView(struct PySlepcNEPObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("vectorsView", 0);

  /* "SLEPc/NEP.pyx":933
 *                 output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPVectorsView(self.nep, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/NEP.pyx":934
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( NEPVectorsView(self.nep, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPVectorsView(__pyx_v_self->nep, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 934, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":923
 *         CHKERR( NEPValuesView(self.nep, vwr) )
 * 
 *     def vectorsView(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Outputs computed eigenvectors to a viewer.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.vectorsView", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":938
 *     #
 * 
 *     def setFunction(self, function, Mat F=None, Mat P=None, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the function to compute the nonlinear Function T(lambda)
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_105setFunction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_104setFunction[] = "NEP.setFunction(self, function, Mat F=None, Mat P=None, args=None, kargs=None)\n\n        Sets the function to compute the nonlinear Function T(lambda)\n        as well as the location to store the matrix.\n\n        Parameters\n        ----------\n        function:\n            Function evaluation routine\n        F: Mat\n            Function matrix\n        P: Mat\n            preconditioner matrix (usually the same as F)\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_105setFunction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_function = 0;
  struct PyPetscMatObject *__pyx_v_F = 0;
  struct PyPetscMatObject *__pyx_v_P = 0;
  PyObject *__pyx_v_args = 0;
  PyObject *__pyx_v_kargs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFunction (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_function,&__pyx_n_s_F,&__pyx_n_s_P,&__pyx_n_s_args,&__pyx_n_s_kargs,0};
    PyObject* values[5] = {0,0,0,0,0};
    values[1] = (PyObject *)((struct PyPetscMatObject *)Py_None);
    values[2] = (PyObject *)((struct PyPetscMatObject *)Py_None);
    values[3] = ((PyObject *)Py_None);
    values[4] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_function)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_F);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_P);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kargs);
          if (value) { values[4] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setFunction") < 0)) __PYX_ERR(20, 938, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_function = values[0];
    __pyx_v_F = ((struct PyPetscMatObject *)values[1]);
    __pyx_v_P = ((struct PyPetscMatObject *)values[2]);
    __pyx_v_args = values[3];
    __pyx_v_kargs = values[4];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setFunction", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 938, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setFunction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_F), __pyx_ptype_8petsc4py_5PETSc_Mat, 1, "F", 0))) __PYX_ERR(20, 938, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_P), __pyx_ptype_8petsc4py_5PETSc_Mat, 1, "P", 0))) __PYX_ERR(20, 938, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_104setFunction(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_function, __pyx_v_F, __pyx_v_P, __pyx_v_args, __pyx_v_kargs);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_104setFunction(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_function, struct PyPetscMatObject *__pyx_v_F, struct PyPetscMatObject *__pyx_v_P, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs) {
  Mat __pyx_v_Fmat;
  Mat __pyx_v_Pmat;
  PyObject *__pyx_v_context = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Mat __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFunction", 0);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);

  /* "SLEPc/NEP.pyx":952
 *             preconditioner matrix (usually the same as F)
 *         """
 *         cdef PetscMat Fmat = F.mat if F is not None else <PetscMat>NULL             # <<<<<<<<<<<<<<
 *         cdef PetscMat Pmat = P.mat if P is not None else Fmat
 *         if function is not None:
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_F) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_F->mat;
  } else {
    __pyx_t_1 = ((Mat)NULL);
  }
  __pyx_v_Fmat = __pyx_t_1;

  /* "SLEPc/NEP.pyx":953
 *         """
 *         cdef PetscMat Fmat = F.mat if F is not None else <PetscMat>NULL
 *         cdef PetscMat Pmat = P.mat if P is not None else Fmat             # <<<<<<<<<<<<<<
 *         if function is not None:
 *             if args is None: args = ()
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_P) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_P->mat;
  } else {
    __pyx_t_1 = __pyx_v_Fmat;
  }
  __pyx_v_Pmat = __pyx_t_1;

  /* "SLEPc/NEP.pyx":954
 *         cdef PetscMat Fmat = F.mat if F is not None else <PetscMat>NULL
 *         cdef PetscMat Pmat = P.mat if P is not None else Fmat
 *         if function is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
  __pyx_t_2 = (__pyx_v_function != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {

    /* "SLEPc/NEP.pyx":955
 *         cdef PetscMat Pmat = P.mat if P is not None else Fmat
 *         if function is not None:
 *             if args is None: args = ()             # <<<<<<<<<<<<<<
 *             if kargs is None: kargs = {}
 *             context = (function, args, kargs)
 */
    __pyx_t_3 = (__pyx_v_args == Py_None);
    __pyx_t_2 = (__pyx_t_3 != 0);
    if (__pyx_t_2) {
      __Pyx_INCREF(__pyx_empty_tuple);
      __Pyx_DECREF_SET(__pyx_v_args, __pyx_empty_tuple);
    }

    /* "SLEPc/NEP.pyx":956
 *         if function is not None:
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}             # <<<<<<<<<<<<<<
 *             context = (function, args, kargs)
 *             self.set_attr('__function__', context)
 */
    __pyx_t_2 = (__pyx_v_kargs == Py_None);
    __pyx_t_3 = (__pyx_t_2 != 0);
    if (__pyx_t_3) {
      __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 956, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF_SET(__pyx_v_kargs, __pyx_t_4);
      __pyx_t_4 = 0;
    }

    /* "SLEPc/NEP.pyx":957
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 *             context = (function, args, kargs)             # <<<<<<<<<<<<<<
 *             self.set_attr('__function__', context)
 *             CHKERR( NEPSetFunction(self.nep, Fmat, Pmat, NEP_Function, <void*>context) )
 */
    __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 957, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_INCREF(__pyx_v_function);
    __Pyx_GIVEREF(__pyx_v_function);
    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_function);
    __Pyx_INCREF(__pyx_v_args);
    __Pyx_GIVEREF(__pyx_v_args);
    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_args);
    __Pyx_INCREF(__pyx_v_kargs);
    __Pyx_GIVEREF(__pyx_v_kargs);
    PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_kargs);
    __pyx_v_context = ((PyObject*)__pyx_t_4);
    __pyx_t_4 = 0;

    /* "SLEPc/NEP.pyx":958
 *             if kargs is None: kargs = {}
 *             context = (function, args, kargs)
 *             self.set_attr('__function__', context)             # <<<<<<<<<<<<<<
 *             CHKERR( NEPSetFunction(self.nep, Fmat, Pmat, NEP_Function, <void*>context) )
 *         else:
 */
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__function__"), __pyx_v_context); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 958, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "SLEPc/NEP.pyx":959
 *             context = (function, args, kargs)
 *             self.set_attr('__function__', context)
 *             CHKERR( NEPSetFunction(self.nep, Fmat, Pmat, NEP_Function, <void*>context) )             # <<<<<<<<<<<<<<
 *         else:
 *             CHKERR( NEPSetFunction(self.nep, Fmat, Pmat, NULL, NULL) )
 */
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetFunction(__pyx_v_self->nep, __pyx_v_Fmat, __pyx_v_Pmat, __pyx_f_8slepc4py_5SLEPc_NEP_Function, ((void *)__pyx_v_context))); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(20, 959, __pyx_L1_error)

    /* "SLEPc/NEP.pyx":954
 *         cdef PetscMat Fmat = F.mat if F is not None else <PetscMat>NULL
 *         cdef PetscMat Pmat = P.mat if P is not None else Fmat
 *         if function is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
    goto __pyx_L3;
  }

  /* "SLEPc/NEP.pyx":961
 *             CHKERR( NEPSetFunction(self.nep, Fmat, Pmat, NEP_Function, <void*>context) )
 *         else:
 *             CHKERR( NEPSetFunction(self.nep, Fmat, Pmat, NULL, NULL) )             # <<<<<<<<<<<<<<
 * 
 *     def getFunction(self):
 */
  /*else*/ {
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetFunction(__pyx_v_self->nep, __pyx_v_Fmat, __pyx_v_Pmat, NULL, NULL)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(20, 961, __pyx_L1_error)
  }
  __pyx_L3:;

  /* "SLEPc/NEP.pyx":938
 *     #
 * 
 *     def setFunction(self, function, Mat F=None, Mat P=None, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the function to compute the nonlinear Function T(lambda)
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setFunction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_context);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":963
 *             CHKERR( NEPSetFunction(self.nep, Fmat, Pmat, NULL, NULL) )
 * 
 *     def getFunction(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the function to compute the nonlinear Function T(lambda) and the matrix.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_107getFunction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_106getFunction[] = "NEP.getFunction(self)\n\n        Returns the function to compute the nonlinear Function T(lambda) and the matrix.\n\n        Parameters\n        ----------\n        F: Mat\n            Function matrix\n        P: Mat\n            preconditioner matrix (usually the same as the F)\n        function:\n            Function evaluation routine\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_107getFunction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getFunction (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getFunction", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getFunction", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_106getFunction(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_106getFunction(struct PySlepcNEPObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_F = 0;
  struct PyPetscMatObject *__pyx_v_P = 0;
  PyObject *__pyx_v_function = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getFunction", 0);

  /* "SLEPc/NEP.pyx":976
 *             Function evaluation routine
 *         """
 *         cdef Mat F = Mat()             # <<<<<<<<<<<<<<
 *         cdef Mat P = Mat()
 *         CHKERR( NEPGetFunction(self.nep, &F.mat, &P.mat, NULL, NULL) )
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 976, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_F = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":977
 *         """
 *         cdef Mat F = Mat()
 *         cdef Mat P = Mat()             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetFunction(self.nep, &F.mat, &P.mat, NULL, NULL) )
 *         PetscINCREF(F.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 977, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_P = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":978
 *         cdef Mat F = Mat()
 *         cdef Mat P = Mat()
 *         CHKERR( NEPGetFunction(self.nep, &F.mat, &P.mat, NULL, NULL) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(F.obj)
 *         PetscINCREF(P.obj)
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetFunction(__pyx_v_self->nep, (&__pyx_v_F->mat), (&__pyx_v_P->mat), NULL, NULL)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 978, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":979
 *         cdef Mat P = Mat()
 *         CHKERR( NEPGetFunction(self.nep, &F.mat, &P.mat, NULL, NULL) )
 *         PetscINCREF(F.obj)             # <<<<<<<<<<<<<<
 *         PetscINCREF(P.obj)
 *         cdef object function = self.get_attr('__function__')
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_F->__pyx_base.obj));

  /* "SLEPc/NEP.pyx":980
 *         CHKERR( NEPGetFunction(self.nep, &F.mat, &P.mat, NULL, NULL) )
 *         PetscINCREF(F.obj)
 *         PetscINCREF(P.obj)             # <<<<<<<<<<<<<<
 *         cdef object function = self.get_attr('__function__')
 *         return (F, P, function)
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_P->__pyx_base.obj));

  /* "SLEPc/NEP.pyx":981
 *         PetscINCREF(F.obj)
 *         PetscINCREF(P.obj)
 *         cdef object function = self.get_attr('__function__')             # <<<<<<<<<<<<<<
 *         return (F, P, function)
 * 
 */
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__function__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 981, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_function = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":982
 *         PetscINCREF(P.obj)
 *         cdef object function = self.get_attr('__function__')
 *         return (F, P, function)             # <<<<<<<<<<<<<<
 * 
 *     def setJacobian(self, jacobian, Mat J=None, args=None, kargs=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 982, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(((PyObject *)__pyx_v_F));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_F));
  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_F));
  __Pyx_INCREF(((PyObject *)__pyx_v_P));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_P));
  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_P));
  __Pyx_INCREF(__pyx_v_function);
  __Pyx_GIVEREF(__pyx_v_function);
  PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_function);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":963
 *             CHKERR( NEPSetFunction(self.nep, Fmat, Pmat, NULL, NULL) )
 * 
 *     def getFunction(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the function to compute the nonlinear Function T(lambda) and the matrix.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getFunction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_F);
  __Pyx_XDECREF((PyObject *)__pyx_v_P);
  __Pyx_XDECREF(__pyx_v_function);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":984
 *         return (F, P, function)
 * 
 *     def setJacobian(self, jacobian, Mat J=None, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the function to compute the Jacobian T'(lambda) as well
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_109setJacobian(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_108setJacobian[] = "NEP.setJacobian(self, jacobian, Mat J=None, args=None, kargs=None)\n\n        Sets the function to compute the Jacobian T'(lambda) as well\n        as the location to store the matrix.\n\n        Parameters\n        ----------\n        jacobian:\n            Jacobian evaluation routine\n        J: Mat\n            Jacobian matrix\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_109setJacobian(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_jacobian = 0;
  struct PyPetscMatObject *__pyx_v_J = 0;
  PyObject *__pyx_v_args = 0;
  PyObject *__pyx_v_kargs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setJacobian (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_jacobian,&__pyx_n_s_J,&__pyx_n_s_args,&__pyx_n_s_kargs,0};
    PyObject* values[4] = {0,0,0,0};
    values[1] = (PyObject *)((struct PyPetscMatObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    values[3] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_jacobian)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_J);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kargs);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setJacobian") < 0)) __PYX_ERR(20, 984, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_jacobian = values[0];
    __pyx_v_J = ((struct PyPetscMatObject *)values[1]);
    __pyx_v_args = values[2];
    __pyx_v_kargs = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setJacobian", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 984, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setJacobian", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_J), __pyx_ptype_8petsc4py_5PETSc_Mat, 1, "J", 0))) __PYX_ERR(20, 984, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_108setJacobian(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_jacobian, __pyx_v_J, __pyx_v_args, __pyx_v_kargs);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_108setJacobian(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_jacobian, struct PyPetscMatObject *__pyx_v_J, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs) {
  Mat __pyx_v_Jmat;
  PyObject *__pyx_v_context = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  Mat __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setJacobian", 0);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);

  /* "SLEPc/NEP.pyx":996
 *             Jacobian matrix
 *         """
 *         cdef PetscMat Jmat = J.mat if J is not None else <PetscMat>NULL             # <<<<<<<<<<<<<<
 *         if jacobian is not None:
 *             if args is None: args = ()
 */
  __pyx_t_2 = (((PyObject *)__pyx_v_J) != Py_None);
  if ((__pyx_t_2 != 0)) {
    __pyx_t_1 = __pyx_v_J->mat;
  } else {
    __pyx_t_1 = ((Mat)NULL);
  }
  __pyx_v_Jmat = __pyx_t_1;

  /* "SLEPc/NEP.pyx":997
 *         """
 *         cdef PetscMat Jmat = J.mat if J is not None else <PetscMat>NULL
 *         if jacobian is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
  __pyx_t_2 = (__pyx_v_jacobian != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {

    /* "SLEPc/NEP.pyx":998
 *         cdef PetscMat Jmat = J.mat if J is not None else <PetscMat>NULL
 *         if jacobian is not None:
 *             if args is None: args = ()             # <<<<<<<<<<<<<<
 *             if kargs is None: kargs = {}
 *             context = (jacobian, args, kargs)
 */
    __pyx_t_3 = (__pyx_v_args == Py_None);
    __pyx_t_2 = (__pyx_t_3 != 0);
    if (__pyx_t_2) {
      __Pyx_INCREF(__pyx_empty_tuple);
      __Pyx_DECREF_SET(__pyx_v_args, __pyx_empty_tuple);
    }

    /* "SLEPc/NEP.pyx":999
 *         if jacobian is not None:
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}             # <<<<<<<<<<<<<<
 *             context = (jacobian, args, kargs)
 *             self.set_attr('__jacobian__', context)
 */
    __pyx_t_2 = (__pyx_v_kargs == Py_None);
    __pyx_t_3 = (__pyx_t_2 != 0);
    if (__pyx_t_3) {
      __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 999, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF_SET(__pyx_v_kargs, __pyx_t_4);
      __pyx_t_4 = 0;
    }

    /* "SLEPc/NEP.pyx":1000
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 *             context = (jacobian, args, kargs)             # <<<<<<<<<<<<<<
 *             self.set_attr('__jacobian__', context)
 *             CHKERR( NEPSetJacobian(self.nep, Jmat, NEP_Jacobian, <void*>context) )
 */
    __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 1000, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_INCREF(__pyx_v_jacobian);
    __Pyx_GIVEREF(__pyx_v_jacobian);
    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_jacobian);
    __Pyx_INCREF(__pyx_v_args);
    __Pyx_GIVEREF(__pyx_v_args);
    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_args);
    __Pyx_INCREF(__pyx_v_kargs);
    __Pyx_GIVEREF(__pyx_v_kargs);
    PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_kargs);
    __pyx_v_context = ((PyObject*)__pyx_t_4);
    __pyx_t_4 = 0;

    /* "SLEPc/NEP.pyx":1001
 *             if kargs is None: kargs = {}
 *             context = (jacobian, args, kargs)
 *             self.set_attr('__jacobian__', context)             # <<<<<<<<<<<<<<
 *             CHKERR( NEPSetJacobian(self.nep, Jmat, NEP_Jacobian, <void*>context) )
 *         else:
 */
    __pyx_t_4 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__jacobian__"), __pyx_v_context); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 1001, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    /* "SLEPc/NEP.pyx":1002
 *             context = (jacobian, args, kargs)
 *             self.set_attr('__jacobian__', context)
 *             CHKERR( NEPSetJacobian(self.nep, Jmat, NEP_Jacobian, <void*>context) )             # <<<<<<<<<<<<<<
 *         else:
 *             CHKERR( NEPSetJacobian(self.nep, Jmat, NULL, NULL) )
 */
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetJacobian(__pyx_v_self->nep, __pyx_v_Jmat, __pyx_f_8slepc4py_5SLEPc_NEP_Jacobian, ((void *)__pyx_v_context))); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(20, 1002, __pyx_L1_error)

    /* "SLEPc/NEP.pyx":997
 *         """
 *         cdef PetscMat Jmat = J.mat if J is not None else <PetscMat>NULL
 *         if jacobian is not None:             # <<<<<<<<<<<<<<
 *             if args is None: args = ()
 *             if kargs is None: kargs = {}
 */
    goto __pyx_L3;
  }

  /* "SLEPc/NEP.pyx":1004
 *             CHKERR( NEPSetJacobian(self.nep, Jmat, NEP_Jacobian, <void*>context) )
 *         else:
 *             CHKERR( NEPSetJacobian(self.nep, Jmat, NULL, NULL) )             # <<<<<<<<<<<<<<
 * 
 *     def getJacobian(self):
 */
  /*else*/ {
    __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetJacobian(__pyx_v_self->nep, __pyx_v_Jmat, NULL, NULL)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(20, 1004, __pyx_L1_error)
  }
  __pyx_L3:;

  /* "SLEPc/NEP.pyx":984
 *         return (F, P, function)
 * 
 *     def setJacobian(self, jacobian, Mat J=None, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the function to compute the Jacobian T'(lambda) as well
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setJacobian", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_context);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1006
 *             CHKERR( NEPSetJacobian(self.nep, Jmat, NULL, NULL) )
 * 
 *     def getJacobian(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the function to compute the Jacobian T'(lambda) and the matrix.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_111getJacobian(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_110getJacobian[] = "NEP.getJacobian(self)\n\n        Returns the function to compute the Jacobian T'(lambda) and the matrix.\n\n        Parameters\n        ----------\n        J: Mat\n            Jacobian matrix\n        jacobian:\n            Jacobian evaluation routine\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_111getJacobian(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getJacobian (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getJacobian", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getJacobian", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_110getJacobian(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_110getJacobian(struct PySlepcNEPObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_J = 0;
  PyObject *__pyx_v_jacobian = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getJacobian", 0);

  /* "SLEPc/NEP.pyx":1017
 *             Jacobian evaluation routine
 *         """
 *         cdef Mat J = Mat()             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetJacobian(self.nep, &J.mat, NULL, NULL) )
 *         PetscINCREF(J.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_J = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1018
 *         """
 *         cdef Mat J = Mat()
 *         CHKERR( NEPGetJacobian(self.nep, &J.mat, NULL, NULL) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(J.obj)
 *         cdef object jacobian = self.get_attr('__jacobian__')
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetJacobian(__pyx_v_self->nep, (&__pyx_v_J->mat), NULL, NULL)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1018, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1019
 *         cdef Mat J = Mat()
 *         CHKERR( NEPGetJacobian(self.nep, &J.mat, NULL, NULL) )
 *         PetscINCREF(J.obj)             # <<<<<<<<<<<<<<
 *         cdef object jacobian = self.get_attr('__jacobian__')
 *         return (J, jacobian)
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_J->__pyx_base.obj));

  /* "SLEPc/NEP.pyx":1020
 *         CHKERR( NEPGetJacobian(self.nep, &J.mat, NULL, NULL) )
 *         PetscINCREF(J.obj)
 *         cdef object jacobian = self.get_attr('__jacobian__')             # <<<<<<<<<<<<<<
 *         return (J, jacobian)
 * 
 */
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__jacobian__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1020, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_jacobian = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1021
 *         PetscINCREF(J.obj)
 *         cdef object jacobian = self.get_attr('__jacobian__')
 *         return (J, jacobian)             # <<<<<<<<<<<<<<
 * 
 *     def setSplitOperator(self, A, f, structure=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1021, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(((PyObject *)__pyx_v_J));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_J));
  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_J));
  __Pyx_INCREF(__pyx_v_jacobian);
  __Pyx_GIVEREF(__pyx_v_jacobian);
  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_jacobian);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1006
 *             CHKERR( NEPSetJacobian(self.nep, Jmat, NULL, NULL) )
 * 
 *     def getJacobian(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the function to compute the Jacobian T'(lambda) and the matrix.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getJacobian", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_J);
  __Pyx_XDECREF(__pyx_v_jacobian);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1023
 *         return (J, jacobian)
 * 
 *     def setSplitOperator(self, A, f, structure=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the operator of the nonlinear eigenvalue problem
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_113setSplitOperator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_112setSplitOperator[] = "NEP.setSplitOperator(self, A, f, structure=None)\n\n        Sets the operator of the nonlinear eigenvalue problem\n        in split form.\n\n        Parameters\n        ----------\n        A: Mat or sequence of Mat\n            Coefficient matrices of the split form.\n        f: sequence of FN\n            Scalar functions of the split form.\n        structure: `PETSc.Mat.Structure` enumerate, optional\n            Structure flag for matrices.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_113setSplitOperator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_A = 0;
  PyObject *__pyx_v_f = 0;
  PyObject *__pyx_v_structure = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSplitOperator (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_A,&__pyx_n_s_f,&__pyx_n_s_structure,0};
    PyObject* values[3] = {0,0,0};
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_A)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_f)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("setSplitOperator", 0, 2, 3, 1); __PYX_ERR(20, 1023, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_structure);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSplitOperator") < 0)) __PYX_ERR(20, 1023, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_A = values[0];
    __pyx_v_f = values[1];
    __pyx_v_structure = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSplitOperator", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1023, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setSplitOperator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_112setSplitOperator(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_A, __pyx_v_f, __pyx_v_structure);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_112setSplitOperator(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_A, PyObject *__pyx_v_f, PyObject *__pyx_v_structure) {
  Mat *__pyx_v_As;
  FN *__pyx_v_Fs;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_n;
  MatStructure __pyx_v_mstr;
  CYTHON_UNUSED PyObject *__pyx_v_tmp1 = 0;
  CYTHON_UNUSED PyObject *__pyx_v_tmp2 = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  Py_ssize_t __pyx_t_4;
  MatStructure __pyx_t_5;
  Py_ssize_t __pyx_t_6;
  Py_ssize_t __pyx_t_7;
  Mat __pyx_t_8;
  FN __pyx_t_9;
  int __pyx_t_10;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSplitOperator", 0);
  __Pyx_INCREF(__pyx_v_A);
  __Pyx_INCREF(__pyx_v_f);

  /* "SLEPc/NEP.pyx":1037
 *             Structure flag for matrices.
 *         """
 *         if isinstance(A, Mat): A = [A]             # <<<<<<<<<<<<<<
 *         if isinstance(f, FN):  f = [f]
 *         cdef PetscMat *As = NULL
 */
  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_A, __pyx_ptype_8petsc4py_5PETSc_Mat); 
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1037, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_A);
    __Pyx_GIVEREF(__pyx_v_A);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_A);
    __Pyx_DECREF_SET(__pyx_v_A, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/NEP.pyx":1038
 *         """
 *         if isinstance(A, Mat): A = [A]
 *         if isinstance(f, FN):  f = [f]             # <<<<<<<<<<<<<<
 *         cdef PetscMat *As = NULL
 *         cdef SlepcFN  *Fs = NULL
 */
  __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_f, __pyx_ptype_8slepc4py_5SLEPc_FN); 
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1038, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_f);
    __Pyx_GIVEREF(__pyx_v_f);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_f);
    __Pyx_DECREF_SET(__pyx_v_f, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/NEP.pyx":1039
 *         if isinstance(A, Mat): A = [A]
 *         if isinstance(f, FN):  f = [f]
 *         cdef PetscMat *As = NULL             # <<<<<<<<<<<<<<
 *         cdef SlepcFN  *Fs = NULL
 *         cdef Py_ssize_t i = 0, n = len(A)
 */
  __pyx_v_As = NULL;

  /* "SLEPc/NEP.pyx":1040
 *         if isinstance(f, FN):  f = [f]
 *         cdef PetscMat *As = NULL
 *         cdef SlepcFN  *Fs = NULL             # <<<<<<<<<<<<<<
 *         cdef Py_ssize_t i = 0, n = len(A)
 *         cdef PetscMatStructure mstr = matstructure(structure)
 */
  __pyx_v_Fs = NULL;

  /* "SLEPc/NEP.pyx":1041
 *         cdef PetscMat *As = NULL
 *         cdef SlepcFN  *Fs = NULL
 *         cdef Py_ssize_t i = 0, n = len(A)             # <<<<<<<<<<<<<<
 *         cdef PetscMatStructure mstr = matstructure(structure)
 *         assert n == len(f)
 */
  __pyx_v_i = 0;
  __pyx_t_4 = PyObject_Length(__pyx_v_A); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(20, 1041, __pyx_L1_error)
  __pyx_v_n = __pyx_t_4;

  /* "SLEPc/NEP.pyx":1042
 *         cdef SlepcFN  *Fs = NULL
 *         cdef Py_ssize_t i = 0, n = len(A)
 *         cdef PetscMatStructure mstr = matstructure(structure)             # <<<<<<<<<<<<<<
 *         assert n == len(f)
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscMat),<void**>&As)
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_matstructure(__pyx_v_structure); if (unlikely(__pyx_t_5 == ((MatStructure)((MatStructure)-1L)))) __PYX_ERR(20, 1042, __pyx_L1_error)
  __pyx_v_mstr = __pyx_t_5;

  /* "SLEPc/NEP.pyx":1043
 *         cdef Py_ssize_t i = 0, n = len(A)
 *         cdef PetscMatStructure mstr = matstructure(structure)
 *         assert n == len(f)             # <<<<<<<<<<<<<<
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscMat),<void**>&As)
 *         cdef tmp2 = allocate(<size_t>n*sizeof(SlepcFN),<void**>&Fs)
 */
  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(!Py_OptimizeFlag)) {
    __pyx_t_4 = PyObject_Length(__pyx_v_f); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(20, 1043, __pyx_L1_error)
    if (unlikely(!((__pyx_v_n == __pyx_t_4) != 0))) {
      PyErr_SetNone(PyExc_AssertionError);
      __PYX_ERR(20, 1043, __pyx_L1_error)
    }
  }
  #endif

  /* "SLEPc/NEP.pyx":1044
 *         cdef PetscMatStructure mstr = matstructure(structure)
 *         assert n == len(f)
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscMat),<void**>&As)             # <<<<<<<<<<<<<<
 *         cdef tmp2 = allocate(<size_t>n*sizeof(SlepcFN),<void**>&Fs)
 *         for i in range(n):
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_n) * (sizeof(Mat))), ((void **)(&__pyx_v_As))); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1044, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp1 = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/NEP.pyx":1045
 *         assert n == len(f)
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscMat),<void**>&As)
 *         cdef tmp2 = allocate(<size_t>n*sizeof(SlepcFN),<void**>&Fs)             # <<<<<<<<<<<<<<
 *         for i in range(n):
 *             As[i] = (<Mat?>A[i]).mat
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_n) * (sizeof(FN))), ((void **)(&__pyx_v_Fs))); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1045, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp2 = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/NEP.pyx":1046
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscMat),<void**>&As)
 *         cdef tmp2 = allocate(<size_t>n*sizeof(SlepcFN),<void**>&Fs)
 *         for i in range(n):             # <<<<<<<<<<<<<<
 *             As[i] = (<Mat?>A[i]).mat
 *             Fs[i] = (<FN?>f[i]).fn
 */
  __pyx_t_4 = __pyx_v_n;
  __pyx_t_6 = __pyx_t_4;
  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
    __pyx_v_i = __pyx_t_7;

    /* "SLEPc/NEP.pyx":1047
 *         cdef tmp2 = allocate(<size_t>n*sizeof(SlepcFN),<void**>&Fs)
 *         for i in range(n):
 *             As[i] = (<Mat?>A[i]).mat             # <<<<<<<<<<<<<<
 *             Fs[i] = (<FN?>f[i]).fn
 *         CHKERR( NEPSetSplitOperator(self.nep, <PetscInt>n, As, Fs, mstr) )
 */
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_A, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1047, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8petsc4py_5PETSc_Mat)))) __PYX_ERR(20, 1047, __pyx_L1_error)
    __pyx_t_8 = ((struct PyPetscMatObject *)__pyx_t_3)->mat;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    (__pyx_v_As[__pyx_v_i]) = __pyx_t_8;

    /* "SLEPc/NEP.pyx":1048
 *         for i in range(n):
 *             As[i] = (<Mat?>A[i]).mat
 *             Fs[i] = (<FN?>f[i]).fn             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSetSplitOperator(self.nep, <PetscInt>n, As, Fs, mstr) )
 * 
 */
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_f, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1048, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8slepc4py_5SLEPc_FN)))) __PYX_ERR(20, 1048, __pyx_L1_error)
    __pyx_t_9 = ((struct PySlepcFNObject *)__pyx_t_3)->fn;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    (__pyx_v_Fs[__pyx_v_i]) = __pyx_t_9;
  }

  /* "SLEPc/NEP.pyx":1049
 *             As[i] = (<Mat?>A[i]).mat
 *             Fs[i] = (<FN?>f[i]).fn
 *         CHKERR( NEPSetSplitOperator(self.nep, <PetscInt>n, As, Fs, mstr) )             # <<<<<<<<<<<<<<
 * 
 *     def getSplitOperator(self):
 */
  __pyx_t_10 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetSplitOperator(__pyx_v_self->nep, ((PetscInt)__pyx_v_n), __pyx_v_As, __pyx_v_Fs, __pyx_v_mstr)); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(20, 1049, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1023
 *         return (J, jacobian)
 * 
 *     def setSplitOperator(self, A, f, structure=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the operator of the nonlinear eigenvalue problem
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setSplitOperator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp1);
  __Pyx_XDECREF(__pyx_v_tmp2);
  __Pyx_XDECREF(__pyx_v_A);
  __Pyx_XDECREF(__pyx_v_f);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1051
 *         CHKERR( NEPSetSplitOperator(self.nep, <PetscInt>n, As, Fs, mstr) )
 * 
 *     def getSplitOperator(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the operator of the nonlinear eigenvalue problem
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_115getSplitOperator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_114getSplitOperator[] = "NEP.getSplitOperator(self)\n\n        Returns the operator of the nonlinear eigenvalue problem\n        in split form.\n\n        Returns\n        -------\n        A: sequence of Mat\n            Coefficient matrices of the split form.\n        f: sequence of FN\n            Scalar functions of the split form.\n        structure: `PETSc.Mat.Structure` enumerate\n            Structure flag for matrices.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_115getSplitOperator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSplitOperator (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSplitOperator", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSplitOperator", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_114getSplitOperator(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_114getSplitOperator(struct PySlepcNEPObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  struct PySlepcFNObject *__pyx_v_f = 0;
  Mat __pyx_v_mat;
  FN __pyx_v_fn;
  PetscInt __pyx_v_i;
  PetscInt __pyx_v_n;
  MatStructure __pyx_v_mstr;
  PyObject *__pyx_v_matrices = 0;
  PyObject *__pyx_v_functions = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PetscInt __pyx_t_3;
  PetscInt __pyx_t_4;
  PetscInt __pyx_t_5;
  int __pyx_t_6;
  PyObject *__pyx_t_7 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSplitOperator", 0);

  /* "SLEPc/NEP.pyx":1067
 *         cdef Mat A
 *         cdef FN  f
 *         cdef PetscMat mat = NULL             # <<<<<<<<<<<<<<
 *         cdef SlepcFN  fn  = NULL
 *         cdef PetscInt i=0, n=0
 */
  __pyx_v_mat = NULL;

  /* "SLEPc/NEP.pyx":1068
 *         cdef FN  f
 *         cdef PetscMat mat = NULL
 *         cdef SlepcFN  fn  = NULL             # <<<<<<<<<<<<<<
 *         cdef PetscInt i=0, n=0
 *         cdef PetscMatStructure mstr
 */
  __pyx_v_fn = NULL;

  /* "SLEPc/NEP.pyx":1069
 *         cdef PetscMat mat = NULL
 *         cdef SlepcFN  fn  = NULL
 *         cdef PetscInt i=0, n=0             # <<<<<<<<<<<<<<
 *         cdef PetscMatStructure mstr
 *         CHKERR( NEPGetSplitOperatorInfo(self.nep, &n, &mstr) )
 */
  __pyx_v_i = 0;
  __pyx_v_n = 0;

  /* "SLEPc/NEP.pyx":1071
 *         cdef PetscInt i=0, n=0
 *         cdef PetscMatStructure mstr
 *         CHKERR( NEPGetSplitOperatorInfo(self.nep, &n, &mstr) )             # <<<<<<<<<<<<<<
 *         cdef object matrices = []
 *         cdef object functions = []
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetSplitOperatorInfo(__pyx_v_self->nep, (&__pyx_v_n), (&__pyx_v_mstr))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1071, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1072
 *         cdef PetscMatStructure mstr
 *         CHKERR( NEPGetSplitOperatorInfo(self.nep, &n, &mstr) )
 *         cdef object matrices = []             # <<<<<<<<<<<<<<
 *         cdef object functions = []
 *         for i in range(n):
 */
  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1072, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_matrices = __pyx_t_2;
  __pyx_t_2 = 0;

  /* "SLEPc/NEP.pyx":1073
 *         CHKERR( NEPGetSplitOperatorInfo(self.nep, &n, &mstr) )
 *         cdef object matrices = []
 *         cdef object functions = []             # <<<<<<<<<<<<<<
 *         for i in range(n):
 *             CHKERR( NEPGetSplitOperatorTerm(self.nep, i, &mat, &fn) )
 */
  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1073, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_functions = __pyx_t_2;
  __pyx_t_2 = 0;

  /* "SLEPc/NEP.pyx":1074
 *         cdef object matrices = []
 *         cdef object functions = []
 *         for i in range(n):             # <<<<<<<<<<<<<<
 *             CHKERR( NEPGetSplitOperatorTerm(self.nep, i, &mat, &fn) )
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)
 */
  __pyx_t_3 = __pyx_v_n;
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_i = __pyx_t_5;

    /* "SLEPc/NEP.pyx":1075
 *         cdef object functions = []
 *         for i in range(n):
 *             CHKERR( NEPGetSplitOperatorTerm(self.nep, i, &mat, &fn) )             # <<<<<<<<<<<<<<
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)
 *             f = FN();  f.fn = fn;   PetscINCREF(f.obj)
 */
    __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetSplitOperatorTerm(__pyx_v_self->nep, __pyx_v_i, (&__pyx_v_mat), (&__pyx_v_fn))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1075, __pyx_L1_error)

    /* "SLEPc/NEP.pyx":1076
 *         for i in range(n):
 *             CHKERR( NEPGetSplitOperatorTerm(self.nep, i, &mat, &fn) )
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)             # <<<<<<<<<<<<<<
 *             f = FN();  f.fn = fn;   PetscINCREF(f.obj)
 *             matrices.append(A)
 */
    __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1076, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_A, ((struct PyPetscMatObject *)__pyx_t_2));
    __pyx_t_2 = 0;
    __pyx_v_A->mat = __pyx_v_mat;
    (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_A->__pyx_base.obj));

    /* "SLEPc/NEP.pyx":1077
 *             CHKERR( NEPGetSplitOperatorTerm(self.nep, i, &mat, &fn) )
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)
 *             f = FN();  f.fn = fn;   PetscINCREF(f.obj)             # <<<<<<<<<<<<<<
 *             matrices.append(A)
 *             functions.append(f)
 */
    __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_FN)); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1077, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_f, ((struct PySlepcFNObject *)__pyx_t_2));
    __pyx_t_2 = 0;
    __pyx_v_f->fn = __pyx_v_fn;
    (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_f->__pyx_base.obj));

    /* "SLEPc/NEP.pyx":1078
 *             A = Mat(); A.mat = mat; PetscINCREF(A.obj)
 *             f = FN();  f.fn = fn;   PetscINCREF(f.obj)
 *             matrices.append(A)             # <<<<<<<<<<<<<<
 *             functions.append(f)
 *         return (matrices, functions, mstr)
 */
    __pyx_t_6 = __Pyx_PyObject_Append(__pyx_v_matrices, ((PyObject *)__pyx_v_A)); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(20, 1078, __pyx_L1_error)

    /* "SLEPc/NEP.pyx":1079
 *             f = FN();  f.fn = fn;   PetscINCREF(f.obj)
 *             matrices.append(A)
 *             functions.append(f)             # <<<<<<<<<<<<<<
 *         return (matrices, functions, mstr)
 * 
 */
    __pyx_t_6 = __Pyx_PyObject_Append(__pyx_v_functions, ((PyObject *)__pyx_v_f)); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(20, 1079, __pyx_L1_error)
  }

  /* "SLEPc/NEP.pyx":1080
 *             matrices.append(A)
 *             functions.append(f)
 *         return (matrices, functions, mstr)             # <<<<<<<<<<<<<<
 * 
 *     def setSplitPreconditioner(self, P, structure=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_MatStructure(__pyx_v_mstr); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1080, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 1080, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_INCREF(__pyx_v_matrices);
  __Pyx_GIVEREF(__pyx_v_matrices);
  PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_v_matrices);
  __Pyx_INCREF(__pyx_v_functions);
  __Pyx_GIVEREF(__pyx_v_functions);
  PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_v_functions);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_2);
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_7;
  __pyx_t_7 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1051
 *         CHKERR( NEPSetSplitOperator(self.nep, <PetscInt>n, As, Fs, mstr) )
 * 
 *     def getSplitOperator(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the operator of the nonlinear eigenvalue problem
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getSplitOperator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_A);
  __Pyx_XDECREF((PyObject *)__pyx_v_f);
  __Pyx_XDECREF(__pyx_v_matrices);
  __Pyx_XDECREF(__pyx_v_functions);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1082
 *         return (matrices, functions, mstr)
 * 
 *     def setSplitPreconditioner(self, P, structure=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the operator in split form from which to build
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_117setSplitPreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_116setSplitPreconditioner[] = "NEP.setSplitPreconditioner(self, P, structure=None)\n\n        Sets the operator in split form from which to build\n        the preconditioner to be used when solving the nonlinear\n        eigenvalue problem in split form.\n\n        Parameters\n        ----------\n        P: Mat or sequence of Mat\n            Coefficient matrices of the split preconditioner.\n        structure: `PETSc.Mat.Structure` enumerate, optional\n            Structure flag for matrices.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_117setSplitPreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_P = 0;
  PyObject *__pyx_v_structure = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSplitPreconditioner (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_P,&__pyx_n_s_structure,0};
    PyObject* values[2] = {0,0};
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_P)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_structure);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSplitPreconditioner") < 0)) __PYX_ERR(20, 1082, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_P = values[0];
    __pyx_v_structure = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSplitPreconditioner", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1082, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setSplitPreconditioner", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_116setSplitPreconditioner(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_P, __pyx_v_structure);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_116setSplitPreconditioner(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_P, PyObject *__pyx_v_structure) {
  Mat *__pyx_v_Ps;
  Py_ssize_t __pyx_v_i;
  Py_ssize_t __pyx_v_n;
  MatStructure __pyx_v_mstr;
  CYTHON_UNUSED PyObject *__pyx_v_tmp1 = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  Py_ssize_t __pyx_t_4;
  MatStructure __pyx_t_5;
  Py_ssize_t __pyx_t_6;
  Py_ssize_t __pyx_t_7;
  Mat __pyx_t_8;
  int __pyx_t_9;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSplitPreconditioner", 0);
  __Pyx_INCREF(__pyx_v_P);

  /* "SLEPc/NEP.pyx":1095
 *             Structure flag for matrices.
 *         """
 *         if isinstance(P, Mat): P = [P]             # <<<<<<<<<<<<<<
 *         cdef PetscMat *Ps = NULL
 *         cdef Py_ssize_t i = 0, n = len(P)
 */
  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_P, __pyx_ptype_8petsc4py_5PETSc_Mat); 
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1095, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_P);
    __Pyx_GIVEREF(__pyx_v_P);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_P);
    __Pyx_DECREF_SET(__pyx_v_P, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/NEP.pyx":1096
 *         """
 *         if isinstance(P, Mat): P = [P]
 *         cdef PetscMat *Ps = NULL             # <<<<<<<<<<<<<<
 *         cdef Py_ssize_t i = 0, n = len(P)
 *         cdef PetscMatStructure mstr = matstructure(structure)
 */
  __pyx_v_Ps = NULL;

  /* "SLEPc/NEP.pyx":1097
 *         if isinstance(P, Mat): P = [P]
 *         cdef PetscMat *Ps = NULL
 *         cdef Py_ssize_t i = 0, n = len(P)             # <<<<<<<<<<<<<<
 *         cdef PetscMatStructure mstr = matstructure(structure)
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscMat),<void**>&Ps)
 */
  __pyx_v_i = 0;
  __pyx_t_4 = PyObject_Length(__pyx_v_P); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(20, 1097, __pyx_L1_error)
  __pyx_v_n = __pyx_t_4;

  /* "SLEPc/NEP.pyx":1098
 *         cdef PetscMat *Ps = NULL
 *         cdef Py_ssize_t i = 0, n = len(P)
 *         cdef PetscMatStructure mstr = matstructure(structure)             # <<<<<<<<<<<<<<
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscMat),<void**>&Ps)
 *         for i in range(n):
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_matstructure(__pyx_v_structure); if (unlikely(__pyx_t_5 == ((MatStructure)((MatStructure)-1L)))) __PYX_ERR(20, 1098, __pyx_L1_error)
  __pyx_v_mstr = __pyx_t_5;

  /* "SLEPc/NEP.pyx":1099
 *         cdef Py_ssize_t i = 0, n = len(P)
 *         cdef PetscMatStructure mstr = matstructure(structure)
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscMat),<void**>&Ps)             # <<<<<<<<<<<<<<
 *         for i in range(n):
 *             Ps[i] = (<Mat?>P[i]).mat
 */
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_allocate((((size_t)__pyx_v_n) * (sizeof(Mat))), ((void **)(&__pyx_v_Ps))); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1099, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_tmp1 = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/NEP.pyx":1100
 *         cdef PetscMatStructure mstr = matstructure(structure)
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscMat),<void**>&Ps)
 *         for i in range(n):             # <<<<<<<<<<<<<<
 *             Ps[i] = (<Mat?>P[i]).mat
 *         CHKERR( NEPSetSplitPreconditioner(self.nep, <PetscInt>n, Ps, mstr) )
 */
  __pyx_t_4 = __pyx_v_n;
  __pyx_t_6 = __pyx_t_4;
  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
    __pyx_v_i = __pyx_t_7;

    /* "SLEPc/NEP.pyx":1101
 *         cdef tmp1 = allocate(<size_t>n*sizeof(PetscMat),<void**>&Ps)
 *         for i in range(n):
 *             Ps[i] = (<Mat?>P[i]).mat             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSetSplitPreconditioner(self.nep, <PetscInt>n, Ps, mstr) )
 * 
 */
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_P, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1101, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_8petsc4py_5PETSc_Mat)))) __PYX_ERR(20, 1101, __pyx_L1_error)
    __pyx_t_8 = ((struct PyPetscMatObject *)__pyx_t_3)->mat;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    (__pyx_v_Ps[__pyx_v_i]) = __pyx_t_8;
  }

  /* "SLEPc/NEP.pyx":1102
 *         for i in range(n):
 *             Ps[i] = (<Mat?>P[i]).mat
 *         CHKERR( NEPSetSplitPreconditioner(self.nep, <PetscInt>n, Ps, mstr) )             # <<<<<<<<<<<<<<
 * 
 *     def getSplitPreconditioner(self):
 */
  __pyx_t_9 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetSplitPreconditioner(__pyx_v_self->nep, ((PetscInt)__pyx_v_n), __pyx_v_Ps, __pyx_v_mstr)); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(20, 1102, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1082
 *         return (matrices, functions, mstr)
 * 
 *     def setSplitPreconditioner(self, P, structure=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the operator in split form from which to build
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setSplitPreconditioner", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp1);
  __Pyx_XDECREF(__pyx_v_P);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1104
 *         CHKERR( NEPSetSplitPreconditioner(self.nep, <PetscInt>n, Ps, mstr) )
 * 
 *     def getSplitPreconditioner(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the operator of the split preconditioner.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_119getSplitPreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_118getSplitPreconditioner[] = "NEP.getSplitPreconditioner(self)\n\n        Returns the operator of the split preconditioner.\n\n        Returns\n        -------\n        P: sequence of Mat\n            Coefficient matrices of the split preconditioner.\n        structure: `PETSc.Mat.Structure` enumerate\n            Structure flag for matrices.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_119getSplitPreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSplitPreconditioner (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSplitPreconditioner", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSplitPreconditioner", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_118getSplitPreconditioner(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_118getSplitPreconditioner(struct PySlepcNEPObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_P = 0;
  Mat __pyx_v_mat;
  PetscInt __pyx_v_i;
  PetscInt __pyx_v_n;
  MatStructure __pyx_v_mstr;
  PyObject *__pyx_v_matrices = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PetscInt __pyx_t_3;
  PetscInt __pyx_t_4;
  PetscInt __pyx_t_5;
  int __pyx_t_6;
  PyObject *__pyx_t_7 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSplitPreconditioner", 0);

  /* "SLEPc/NEP.pyx":1116
 *         """
 *         cdef Mat P
 *         cdef PetscMat mat = NULL             # <<<<<<<<<<<<<<
 *         cdef PetscInt i=0, n=0
 *         cdef PetscMatStructure mstr
 */
  __pyx_v_mat = NULL;

  /* "SLEPc/NEP.pyx":1117
 *         cdef Mat P
 *         cdef PetscMat mat = NULL
 *         cdef PetscInt i=0, n=0             # <<<<<<<<<<<<<<
 *         cdef PetscMatStructure mstr
 *         CHKERR( NEPGetSplitPreconditionerInfo(self.nep, &n, &mstr) )
 */
  __pyx_v_i = 0;
  __pyx_v_n = 0;

  /* "SLEPc/NEP.pyx":1119
 *         cdef PetscInt i=0, n=0
 *         cdef PetscMatStructure mstr
 *         CHKERR( NEPGetSplitPreconditionerInfo(self.nep, &n, &mstr) )             # <<<<<<<<<<<<<<
 *         cdef object matrices = []
 *         for i in range(n):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetSplitPreconditionerInfo(__pyx_v_self->nep, (&__pyx_v_n), (&__pyx_v_mstr))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1119, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1120
 *         cdef PetscMatStructure mstr
 *         CHKERR( NEPGetSplitPreconditionerInfo(self.nep, &n, &mstr) )
 *         cdef object matrices = []             # <<<<<<<<<<<<<<
 *         for i in range(n):
 *             CHKERR( NEPGetSplitPreconditionerTerm(self.nep, i, &mat) )
 */
  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1120, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_matrices = __pyx_t_2;
  __pyx_t_2 = 0;

  /* "SLEPc/NEP.pyx":1121
 *         CHKERR( NEPGetSplitPreconditionerInfo(self.nep, &n, &mstr) )
 *         cdef object matrices = []
 *         for i in range(n):             # <<<<<<<<<<<<<<
 *             CHKERR( NEPGetSplitPreconditionerTerm(self.nep, i, &mat) )
 *             P = Mat(); P.mat = mat; PetscINCREF(P.obj)
 */
  __pyx_t_3 = __pyx_v_n;
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_i = __pyx_t_5;

    /* "SLEPc/NEP.pyx":1122
 *         cdef object matrices = []
 *         for i in range(n):
 *             CHKERR( NEPGetSplitPreconditionerTerm(self.nep, i, &mat) )             # <<<<<<<<<<<<<<
 *             P = Mat(); P.mat = mat; PetscINCREF(P.obj)
 *             matrices.append(P)
 */
    __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetSplitPreconditionerTerm(__pyx_v_self->nep, __pyx_v_i, (&__pyx_v_mat))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1122, __pyx_L1_error)

    /* "SLEPc/NEP.pyx":1123
 *         for i in range(n):
 *             CHKERR( NEPGetSplitPreconditionerTerm(self.nep, i, &mat) )
 *             P = Mat(); P.mat = mat; PetscINCREF(P.obj)             # <<<<<<<<<<<<<<
 *             matrices.append(P)
 *         return (matrices, mstr)
 */
    __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1123, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_P, ((struct PyPetscMatObject *)__pyx_t_2));
    __pyx_t_2 = 0;
    __pyx_v_P->mat = __pyx_v_mat;
    (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_P->__pyx_base.obj));

    /* "SLEPc/NEP.pyx":1124
 *             CHKERR( NEPGetSplitPreconditionerTerm(self.nep, i, &mat) )
 *             P = Mat(); P.mat = mat; PetscINCREF(P.obj)
 *             matrices.append(P)             # <<<<<<<<<<<<<<
 *         return (matrices, mstr)
 * 
 */
    __pyx_t_6 = __Pyx_PyObject_Append(__pyx_v_matrices, ((PyObject *)__pyx_v_P)); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(20, 1124, __pyx_L1_error)
  }

  /* "SLEPc/NEP.pyx":1125
 *             P = Mat(); P.mat = mat; PetscINCREF(P.obj)
 *             matrices.append(P)
 *         return (matrices, mstr)             # <<<<<<<<<<<<<<
 * 
 *     def getTwoSided(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_MatStructure(__pyx_v_mstr); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1125, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 1125, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_INCREF(__pyx_v_matrices);
  __Pyx_GIVEREF(__pyx_v_matrices);
  PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_v_matrices);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2);
  __pyx_t_2 = 0;
  __pyx_r = __pyx_t_7;
  __pyx_t_7 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1104
 *         CHKERR( NEPSetSplitPreconditioner(self.nep, <PetscInt>n, Ps, mstr) )
 * 
 *     def getSplitPreconditioner(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the operator of the split preconditioner.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getSplitPreconditioner", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_P);
  __Pyx_XDECREF(__pyx_v_matrices);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1127
 *         return (matrices, mstr)
 * 
 *     def getTwoSided(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether a two-sided variant
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_121getTwoSided(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_120getTwoSided[] = "NEP.getTwoSided(self)\n\n        Returns the flag indicating whether a two-sided variant\n        of the algorithm is being used or not.\n\n        Returns\n        -------\n        twosided: bool\n            Whether the two-sided variant is to be used or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_121getTwoSided(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTwoSided (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTwoSided", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTwoSided", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_120getTwoSided(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_120getTwoSided(struct PySlepcNEPObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTwoSided", 0);

  /* "SLEPc/NEP.pyx":1137
 *             Whether the two-sided variant is to be used or not.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( NEPGetTwoSided(self.nep, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/NEP.pyx":1138
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( NEPGetTwoSided(self.nep, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPGetTwoSided(__pyx_v_self->nep, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1138, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1139
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( NEPGetTwoSided(self.nep, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setTwoSided(self, twosided):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1139, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1127
 *         return (matrices, mstr)
 * 
 *     def getTwoSided(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag indicating whether a two-sided variant
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getTwoSided", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1141
 *         return toBool(tval)
 * 
 *     def setTwoSided(self, twosided):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the solver to use a two-sided variant so that left
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_123setTwoSided(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_122setTwoSided[] = "NEP.setTwoSided(self, twosided)\n\n        Sets the solver to use a two-sided variant so that left\n        eigenvectors are also computed.\n\n        Parameters\n        ----------\n        twosided: bool\n            Whether the two-sided variant is to be used or not.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_123setTwoSided(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_twosided = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTwoSided (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_twosided,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_twosided)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTwoSided") < 0)) __PYX_ERR(20, 1141, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_twosided = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTwoSided", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1141, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setTwoSided", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_122setTwoSided(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_twosided);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_122setTwoSided(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_twosided) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTwoSided", 0);

  /* "SLEPc/NEP.pyx":1151
 *             Whether the two-sided variant is to be used or not.
 *         """
 *         cdef PetscBool tval = asBool(twosided)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSetTwoSided(self.nep, tval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_twosided); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(20, 1151, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/NEP.pyx":1152
 *         """
 *         cdef PetscBool tval = asBool(twosided)
 *         CHKERR( NEPSetTwoSided(self.nep, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def applyResolvent(self, omega, Vec v, Vec r, RG rg=None):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSetTwoSided(__pyx_v_self->nep, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1152, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1141
 *         return toBool(tval)
 * 
 *     def setTwoSided(self, twosided):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the solver to use a two-sided variant so that left
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setTwoSided", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1154
 *         CHKERR( NEPSetTwoSided(self.nep, tval) )
 * 
 *     def applyResolvent(self, omega, Vec v, Vec r, RG rg=None):             # <<<<<<<<<<<<<<
 *         """
 *         Applies the resolvent T^{-1}(z) to a given vector.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_125applyResolvent(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_124applyResolvent[] = "NEP.applyResolvent(self, omega, Vec v, Vec r, RG rg=None)\n\n        Applies the resolvent T^{-1}(z) to a given vector.\n\n        Parameters\n        ----------\n        omega: scalar\n            Value where the resolvent must be evaluated.\n        v: Vec\n            Input vector.\n        r: Vec\n            Placeholder for the result vector.\n        rg: `RG` object, optional\n            Region.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_125applyResolvent(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_omega = 0;
  struct PyPetscVecObject *__pyx_v_v = 0;
  struct PyPetscVecObject *__pyx_v_r = 0;
  struct PySlepcRGObject *__pyx_v_rg = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("applyResolvent (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_omega,&__pyx_n_s_v,&__pyx_n_s_r,&__pyx_n_s_rg,0};
    PyObject* values[4] = {0,0,0,0};
    values[3] = (PyObject *)((struct PySlepcRGObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_omega)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_v)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("applyResolvent", 0, 3, 4, 1); __PYX_ERR(20, 1154, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_r)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("applyResolvent", 0, 3, 4, 2); __PYX_ERR(20, 1154, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rg);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "applyResolvent") < 0)) __PYX_ERR(20, 1154, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_omega = values[0];
    __pyx_v_v = ((struct PyPetscVecObject *)values[1]);
    __pyx_v_r = ((struct PyPetscVecObject *)values[2]);
    __pyx_v_rg = ((struct PySlepcRGObject *)values[3]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("applyResolvent", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1154, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.applyResolvent", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "v", 0))) __PYX_ERR(20, 1154, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_r), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "r", 0))) __PYX_ERR(20, 1154, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rg), __pyx_ptype_8slepc4py_5SLEPc_RG, 1, "rg", 0))) __PYX_ERR(20, 1154, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_124applyResolvent(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_omega, __pyx_v_v, __pyx_v_r, __pyx_v_rg);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_124applyResolvent(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_omega, struct PyPetscVecObject *__pyx_v_v, struct PyPetscVecObject *__pyx_v_r, struct PySlepcRGObject *__pyx_v_rg) {
  PetscScalar __pyx_v_sval;
  RG __pyx_v_region;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscScalar __pyx_t_1;
  RG __pyx_t_2;
  int __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("applyResolvent", 0);

  /* "SLEPc/NEP.pyx":1169
 *             Region.
 *         """
 *         cdef PetscScalar sval = asScalar(omega)             # <<<<<<<<<<<<<<
 *         cdef SlepcRG region = rg.rg if rg is not None else <SlepcRG>NULL
 *         CHKERR( NEPApplyResolvent(self.nep, region, sval, v.vec, r.vec) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asScalar(__pyx_v_omega); if (unlikely(__pyx_t_1 == ((PetscScalar)((PetscScalar)(-1.0))) && PyErr_Occurred())) __PYX_ERR(20, 1169, __pyx_L1_error)
  __pyx_v_sval = __pyx_t_1;

  /* "SLEPc/NEP.pyx":1170
 *         """
 *         cdef PetscScalar sval = asScalar(omega)
 *         cdef SlepcRG region = rg.rg if rg is not None else <SlepcRG>NULL             # <<<<<<<<<<<<<<
 *         CHKERR( NEPApplyResolvent(self.nep, region, sval, v.vec, r.vec) )
 * 
 */
  __pyx_t_3 = (((PyObject *)__pyx_v_rg) != Py_None);
  if ((__pyx_t_3 != 0)) {
    __pyx_t_2 = __pyx_v_rg->rg;
  } else {
    __pyx_t_2 = ((RG)NULL);
  }
  __pyx_v_region = __pyx_t_2;

  /* "SLEPc/NEP.pyx":1171
 *         cdef PetscScalar sval = asScalar(omega)
 *         cdef SlepcRG region = rg.rg if rg is not None else <SlepcRG>NULL
 *         CHKERR( NEPApplyResolvent(self.nep, region, sval, v.vec, r.vec) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPApplyResolvent(__pyx_v_self->nep, __pyx_v_region, __pyx_v_sval, __pyx_v_v->vec, __pyx_v_r->vec)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(20, 1171, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1154
 *         CHKERR( NEPSetTwoSided(self.nep, tval) )
 * 
 *     def applyResolvent(self, omega, Vec v, Vec r, RG rg=None):             # <<<<<<<<<<<<<<
 *         """
 *         Applies the resolvent T^{-1}(z) to a given vector.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.applyResolvent", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1175
 *     #
 * 
 *     def setRIILagPreconditioner(self, lag):             # <<<<<<<<<<<<<<
 *         """
 *         Determines when the preconditioner is rebuilt in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_127setRIILagPreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_126setRIILagPreconditioner[] = "NEP.setRIILagPreconditioner(self, lag)\n\n        Determines when the preconditioner is rebuilt in the\n        nonlinear solve.\n\n        Parameters\n        ----------\n        lag: int\n            0 indicates NEVER rebuild, 1 means rebuild every time the Jacobian is\n            computed within the nonlinear iteration, 2 means every second time\n            the Jacobian is built, etc.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_127setRIILagPreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_lag = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRIILagPreconditioner (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lag,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lag)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRIILagPreconditioner") < 0)) __PYX_ERR(20, 1175, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_lag = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRIILagPreconditioner", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1175, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRIILagPreconditioner", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_126setRIILagPreconditioner(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_lag);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_126setRIILagPreconditioner(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_lag) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRIILagPreconditioner", 0);

  /* "SLEPc/NEP.pyx":1187
 *             the Jacobian is built, etc.
 *         """
 *         cdef PetscInt ival = asInt(lag)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPRIISetLagPreconditioner(self.nep, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_lag); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 1187, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/NEP.pyx":1188
 *         """
 *         cdef PetscInt ival = asInt(lag)
 *         CHKERR( NEPRIISetLagPreconditioner(self.nep, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getRIILagPreconditioner(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPRIISetLagPreconditioner(__pyx_v_self->nep, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1188, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1175
 *     #
 * 
 *     def setRIILagPreconditioner(self, lag):             # <<<<<<<<<<<<<<
 *         """
 *         Determines when the preconditioner is rebuilt in the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRIILagPreconditioner", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1190
 *         CHKERR( NEPRIISetLagPreconditioner(self.nep, ival) )
 * 
 *     def getRIILagPreconditioner(self):             # <<<<<<<<<<<<<<
 *         """
 *         Indicates how often the preconditioner is rebuilt.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_129getRIILagPreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_128getRIILagPreconditioner[] = "NEP.getRIILagPreconditioner(self)\n\n        Indicates how often the preconditioner is rebuilt.\n\n        Returns\n        -------\n        lag: int\n            The lag parameter.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_129getRIILagPreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRIILagPreconditioner (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRIILagPreconditioner", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRIILagPreconditioner", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_128getRIILagPreconditioner(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_128getRIILagPreconditioner(struct PySlepcNEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRIILagPreconditioner", 0);

  /* "SLEPc/NEP.pyx":1199
 *             The lag parameter.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPRIIGetLagPreconditioner(self.nep, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/NEP.pyx":1200
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( NEPRIIGetLagPreconditioner(self.nep, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPRIIGetLagPreconditioner(__pyx_v_self->nep, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1200, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1201
 *         cdef PetscInt ival = 0
 *         CHKERR( NEPRIIGetLagPreconditioner(self.nep, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def setRIIConstCorrectionTol(self, cct):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1190
 *         CHKERR( NEPRIISetLagPreconditioner(self.nep, ival) )
 * 
 *     def getRIILagPreconditioner(self):             # <<<<<<<<<<<<<<
 *         """
 *         Indicates how often the preconditioner is rebuilt.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getRIILagPreconditioner", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1203
 *         return toInt(ival)
 * 
 *     def setRIIConstCorrectionTol(self, cct):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to keep the tolerance used in the linear solver constant.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_131setRIIConstCorrectionTol(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_130setRIIConstCorrectionTol[] = "NEP.setRIIConstCorrectionTol(self, cct)\n\n        Sets a flag to keep the tolerance used in the linear solver constant.\n\n        Parameters\n        ----------\n        cct: bool\n             If True, the `KSP` relative tolerance is constant.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_131setRIIConstCorrectionTol(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_cct = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRIIConstCorrectionTol (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cct,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_cct)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRIIConstCorrectionTol") < 0)) __PYX_ERR(20, 1203, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_cct = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRIIConstCorrectionTol", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1203, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRIIConstCorrectionTol", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_130setRIIConstCorrectionTol(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_cct);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_130setRIIConstCorrectionTol(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_cct) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRIIConstCorrectionTol", 0);

  /* "SLEPc/NEP.pyx":1212
 *              If True, the `KSP` relative tolerance is constant.
 *         """
 *         cdef PetscBool val = asBool(cct)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPRIISetConstCorrectionTol(self.nep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_cct); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(20, 1212, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/NEP.pyx":1213
 *         """
 *         cdef PetscBool val = asBool(cct)
 *         CHKERR( NEPRIISetConstCorrectionTol(self.nep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getRIIConstCorrectionTol(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPRIISetConstCorrectionTol(__pyx_v_self->nep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1213, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1203
 *         return toInt(ival)
 * 
 *     def setRIIConstCorrectionTol(self, cct):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to keep the tolerance used in the linear solver constant.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRIIConstCorrectionTol", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1215
 *         CHKERR( NEPRIISetConstCorrectionTol(self.nep, val) )
 * 
 *     def getRIIConstCorrectionTol(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the constant tolerance flag.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_133getRIIConstCorrectionTol(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_132getRIIConstCorrectionTol[] = "NEP.getRIIConstCorrectionTol(self)\n\n        Returns the constant tolerance flag.\n\n        Returns\n        -------\n        cct: bool\n             If True, the `KSP` relative tolerance is constant.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_133getRIIConstCorrectionTol(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRIIConstCorrectionTol (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRIIConstCorrectionTol", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRIIConstCorrectionTol", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_132getRIIConstCorrectionTol(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_132getRIIConstCorrectionTol(struct PySlepcNEPObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRIIConstCorrectionTol", 0);

  /* "SLEPc/NEP.pyx":1224
 *              If True, the `KSP` relative tolerance is constant.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( NEPRIIGetConstCorrectionTol(self.nep, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/NEP.pyx":1225
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( NEPRIIGetConstCorrectionTol(self.nep, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPRIIGetConstCorrectionTol(__pyx_v_self->nep, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1225, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1226
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( NEPRIIGetConstCorrectionTol(self.nep, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setRIIMaximumIterations(self, its):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1226, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1215
 *         CHKERR( NEPRIISetConstCorrectionTol(self.nep, val) )
 * 
 *     def getRIIConstCorrectionTol(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the constant tolerance flag.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getRIIConstCorrectionTol", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1228
 *         return toBool(tval)
 * 
 *     def setRIIMaximumIterations(self, its):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the maximum number of inner iterations to be used in
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_135setRIIMaximumIterations(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_134setRIIMaximumIterations[] = "NEP.setRIIMaximumIterations(self, its)\n\n        Sets the maximum number of inner iterations to be used in\n        the RII solver. These are the Newton iterations related to the\n        computation of the nonlinear Rayleigh functional.\n\n        Parameters\n        ----------\n        its: int\n             Maximum inner iterations.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_135setRIIMaximumIterations(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_its = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRIIMaximumIterations (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_its,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_its)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRIIMaximumIterations") < 0)) __PYX_ERR(20, 1228, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_its = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRIIMaximumIterations", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1228, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRIIMaximumIterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_134setRIIMaximumIterations(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_its);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_134setRIIMaximumIterations(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_its) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRIIMaximumIterations", 0);

  /* "SLEPc/NEP.pyx":1239
 *              Maximum inner iterations.
 *         """
 *         cdef PetscInt ival = asInt(its)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPRIISetMaximumIterations(self.nep, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_its); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 1239, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/NEP.pyx":1240
 *         """
 *         cdef PetscInt ival = asInt(its)
 *         CHKERR( NEPRIISetMaximumIterations(self.nep, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getRIIMaximumIterations(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPRIISetMaximumIterations(__pyx_v_self->nep, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1240, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1228
 *         return toBool(tval)
 * 
 *     def setRIIMaximumIterations(self, its):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the maximum number of inner iterations to be used in
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRIIMaximumIterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1242
 *         CHKERR( NEPRIISetMaximumIterations(self.nep, ival) )
 * 
 *     def getRIIMaximumIterations(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the maximum number of inner iterations of RII.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_137getRIIMaximumIterations(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_136getRIIMaximumIterations[] = "NEP.getRIIMaximumIterations(self)\n\n        Gets the maximum number of inner iterations of RII.\n\n        Returns\n        -------\n        its: int\n             Maximum inner iterations.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_137getRIIMaximumIterations(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRIIMaximumIterations (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRIIMaximumIterations", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRIIMaximumIterations", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_136getRIIMaximumIterations(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_136getRIIMaximumIterations(struct PySlepcNEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRIIMaximumIterations", 0);

  /* "SLEPc/NEP.pyx":1251
 *              Maximum inner iterations.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPRIIGetMaximumIterations(self.nep, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/NEP.pyx":1252
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( NEPRIIGetMaximumIterations(self.nep, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPRIIGetMaximumIterations(__pyx_v_self->nep, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1252, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1253
 *         cdef PetscInt ival = 0
 *         CHKERR( NEPRIIGetMaximumIterations(self.nep, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def setRIIHermitian(self, herm):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1253, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1242
 *         CHKERR( NEPRIISetMaximumIterations(self.nep, ival) )
 * 
 *     def getRIIMaximumIterations(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the maximum number of inner iterations of RII.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getRIIMaximumIterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1255
 *         return toInt(ival)
 * 
 *     def setRIIHermitian(self, herm):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to indicate if the Hermitian version of the scalar
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_139setRIIHermitian(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_138setRIIHermitian[] = "NEP.setRIIHermitian(self, herm)\n\n        Sets a flag to indicate if the Hermitian version of the scalar\n        nonlinear equation must be used by the solver.\n\n        Parameters\n        ----------\n        herm: bool\n              If True, the Hermitian version is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_139setRIIHermitian(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_herm = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRIIHermitian (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_herm,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_herm)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRIIHermitian") < 0)) __PYX_ERR(20, 1255, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_herm = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRIIHermitian", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1255, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRIIHermitian", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_138setRIIHermitian(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_herm);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_138setRIIHermitian(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_herm) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRIIHermitian", 0);

  /* "SLEPc/NEP.pyx":1265
 *               If True, the Hermitian version is used.
 *         """
 *         cdef PetscBool val = asBool(herm)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPRIISetHermitian(self.nep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_herm); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(20, 1265, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/NEP.pyx":1266
 *         """
 *         cdef PetscBool val = asBool(herm)
 *         CHKERR( NEPRIISetHermitian(self.nep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getRIIHermitian(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPRIISetHermitian(__pyx_v_self->nep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1266, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1255
 *         return toInt(ival)
 * 
 *     def setRIIHermitian(self, herm):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a flag to indicate if the Hermitian version of the scalar
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRIIHermitian", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1268
 *         CHKERR( NEPRIISetHermitian(self.nep, val) )
 * 
 *     def getRIIHermitian(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag about using the Hermitian version of the scalar
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_141getRIIHermitian(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_140getRIIHermitian[] = "NEP.getRIIHermitian(self)\n\n        Returns the flag about using the Hermitian version of the scalar\n        nonlinear equation.\n\n        Returns\n        -------\n        herm: bool\n              If True, the Hermitian version is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_141getRIIHermitian(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRIIHermitian (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRIIHermitian", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRIIHermitian", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_140getRIIHermitian(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_140getRIIHermitian(struct PySlepcNEPObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRIIHermitian", 0);

  /* "SLEPc/NEP.pyx":1278
 *               If True, the Hermitian version is used.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( NEPRIIGetHermitian(self.nep, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/NEP.pyx":1279
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( NEPRIIGetHermitian(self.nep, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPRIIGetHermitian(__pyx_v_self->nep, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1279, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1280
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( NEPRIIGetHermitian(self.nep, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setRIIDeflationThreshold(self, deftol):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1280, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1268
 *         CHKERR( NEPRIISetHermitian(self.nep, val) )
 * 
 *     def getRIIHermitian(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the flag about using the Hermitian version of the scalar
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getRIIHermitian", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1282
 *         return toBool(tval)
 * 
 *     def setRIIDeflationThreshold(self, deftol):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the threshold value used to switch between deflated and
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_143setRIIDeflationThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_142setRIIDeflationThreshold[] = "NEP.setRIIDeflationThreshold(self, deftol)\n\n        Sets the threshold value used to switch between deflated and\n        non-deflated iteration.\n\n        Parameters\n        ----------\n        deftol: float\n                The threshold value.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_143setRIIDeflationThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_deftol = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRIIDeflationThreshold (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_deftol,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_deftol)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRIIDeflationThreshold") < 0)) __PYX_ERR(20, 1282, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_deftol = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRIIDeflationThreshold", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1282, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRIIDeflationThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_142setRIIDeflationThreshold(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_deftol);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_142setRIIDeflationThreshold(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_deftol) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRIIDeflationThreshold", 0);

  /* "SLEPc/NEP.pyx":1292
 *                 The threshold value.
 *         """
 *         cdef PetscReal val = asReal(deftol)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPRIISetDeflationThreshold(self.nep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_deftol); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(20, 1292, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/NEP.pyx":1293
 *         """
 *         cdef PetscReal val = asReal(deftol)
 *         CHKERR( NEPRIISetDeflationThreshold(self.nep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getRIIDeflationThreshold(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPRIISetDeflationThreshold(__pyx_v_self->nep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1293, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1282
 *         return toBool(tval)
 * 
 *     def setRIIDeflationThreshold(self, deftol):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the threshold value used to switch between deflated and
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRIIDeflationThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1295
 *         CHKERR( NEPRIISetDeflationThreshold(self.nep, val) )
 * 
 *     def getRIIDeflationThreshold(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the threshold value that controls deflation.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_145getRIIDeflationThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_144getRIIDeflationThreshold[] = "NEP.getRIIDeflationThreshold(self)\n\n        Returns the threshold value that controls deflation.\n\n        Returns\n        -------\n        deftol: float\n                The threshold value.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_145getRIIDeflationThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRIIDeflationThreshold (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRIIDeflationThreshold", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRIIDeflationThreshold", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_144getRIIDeflationThreshold(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_144getRIIDeflationThreshold(struct PySlepcNEPObject *__pyx_v_self) {
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRIIDeflationThreshold", 0);

  /* "SLEPc/NEP.pyx":1304
 *                 The threshold value.
 *         """
 *         cdef PetscReal rval = 0.0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPRIIGetDeflationThreshold(self.nep, &rval) )
 *         return toReal(rval)
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/NEP.pyx":1305
 *         """
 *         cdef PetscReal rval = 0.0
 *         CHKERR( NEPRIIGetDeflationThreshold(self.nep, &rval) )             # <<<<<<<<<<<<<<
 *         return toReal(rval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPRIIGetDeflationThreshold(__pyx_v_self->nep, (&__pyx_v_rval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1305, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1306
 *         cdef PetscReal rval = 0.0
 *         CHKERR( NEPRIIGetDeflationThreshold(self.nep, &rval) )
 *         return toReal(rval)             # <<<<<<<<<<<<<<
 * 
 *     def setRIIKSP(self, KSP ksp):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1306, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1295
 *         CHKERR( NEPRIISetDeflationThreshold(self.nep, val) )
 * 
 *     def getRIIDeflationThreshold(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the threshold value that controls deflation.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getRIIDeflationThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1308
 *         return toReal(rval)
 * 
 *     def setRIIKSP(self, KSP ksp):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a linear solver object to the nonlinear eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_147setRIIKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_146setRIIKSP[] = "NEP.setRIIKSP(self, KSP ksp)\n\n        Associate a linear solver object to the nonlinear eigensolver.\n\n        Parameters\n        ----------\n        ksp: `KSP`\n             The linear solver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_147setRIIKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscKSPObject *__pyx_v_ksp = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setRIIKSP (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ksp,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ksp)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setRIIKSP") < 0)) __PYX_ERR(20, 1308, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_ksp = ((struct PyPetscKSPObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setRIIKSP", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1308, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRIIKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ksp), __pyx_ptype_8petsc4py_5PETSc_KSP, 0, "ksp", 0))) __PYX_ERR(20, 1308, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_146setRIIKSP(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_ksp);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_146setRIIKSP(struct PySlepcNEPObject *__pyx_v_self, struct PyPetscKSPObject *__pyx_v_ksp) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setRIIKSP", 0);

  /* "SLEPc/NEP.pyx":1317
 *              The linear solver object.
 *         """
 *         CHKERR( NEPRIISetKSP(self.nep, ksp.ksp) )             # <<<<<<<<<<<<<<
 * 
 *     def getRIIKSP(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPRIISetKSP(__pyx_v_self->nep, __pyx_v_ksp->ksp)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1317, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1308
 *         return toReal(rval)
 * 
 *     def setRIIKSP(self, KSP ksp):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a linear solver object to the nonlinear eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setRIIKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1319
 *         CHKERR( NEPRIISetKSP(self.nep, ksp.ksp) )
 * 
 *     def getRIIKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the linear solver object associated with the nonlinear eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_149getRIIKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_148getRIIKSP[] = "NEP.getRIIKSP(self)\n\n        Retrieve the linear solver object associated with the nonlinear eigensolver.\n\n        Returns\n        -------\n        ksp: `KSP`\n             The linear solver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_149getRIIKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getRIIKSP (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getRIIKSP", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRIIKSP", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_148getRIIKSP(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_148getRIIKSP(struct PySlepcNEPObject *__pyx_v_self) {
  struct PyPetscKSPObject *__pyx_v_ksp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getRIIKSP", 0);

  /* "SLEPc/NEP.pyx":1328
 *              The linear solver object.
 *         """
 *         cdef KSP ksp = KSP()             # <<<<<<<<<<<<<<
 *         CHKERR( NEPRIIGetKSP(self.nep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_KSP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1328, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ksp = ((struct PyPetscKSPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1329
 *         """
 *         cdef KSP ksp = KSP()
 *         CHKERR( NEPRIIGetKSP(self.nep, &ksp.ksp) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(ksp.obj)
 *         return ksp
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPRIIGetKSP(__pyx_v_self->nep, (&__pyx_v_ksp->ksp))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1329, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1330
 *         cdef KSP ksp = KSP()
 *         CHKERR( NEPRIIGetKSP(self.nep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)             # <<<<<<<<<<<<<<
 *         return ksp
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ksp->__pyx_base.obj));

  /* "SLEPc/NEP.pyx":1331
 *         CHKERR( NEPRIIGetKSP(self.nep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 *         return ksp             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ksp));
  __pyx_r = ((PyObject *)__pyx_v_ksp);
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1319
 *         CHKERR( NEPRIISetKSP(self.nep, ksp.ksp) )
 * 
 *     def getRIIKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the linear solver object associated with the nonlinear eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getRIIKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ksp);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1335
 *     #
 * 
 *     def setSLPDeflationThreshold(self, deftol):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the threshold value used to switch between deflated and
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_151setSLPDeflationThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_150setSLPDeflationThreshold[] = "NEP.setSLPDeflationThreshold(self, deftol)\n\n        Sets the threshold value used to switch between deflated and\n        non-deflated iteration.\n\n        Parameters\n        ----------\n        deftol: float\n                The threshold value.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_151setSLPDeflationThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_deftol = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSLPDeflationThreshold (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_deftol,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_deftol)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSLPDeflationThreshold") < 0)) __PYX_ERR(20, 1335, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_deftol = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSLPDeflationThreshold", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1335, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setSLPDeflationThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_150setSLPDeflationThreshold(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_deftol);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_150setSLPDeflationThreshold(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_deftol) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSLPDeflationThreshold", 0);

  /* "SLEPc/NEP.pyx":1345
 *                 The threshold value.
 *         """
 *         cdef PetscReal val = asReal(deftol)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSLPSetDeflationThreshold(self.nep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_deftol); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(20, 1345, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/NEP.pyx":1346
 *         """
 *         cdef PetscReal val = asReal(deftol)
 *         CHKERR( NEPSLPSetDeflationThreshold(self.nep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getSLPDeflationThreshold(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSLPSetDeflationThreshold(__pyx_v_self->nep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1346, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1335
 *     #
 * 
 *     def setSLPDeflationThreshold(self, deftol):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the threshold value used to switch between deflated and
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setSLPDeflationThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1348
 *         CHKERR( NEPSLPSetDeflationThreshold(self.nep, val) )
 * 
 *     def getSLPDeflationThreshold(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the threshold value that controls deflation.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_153getSLPDeflationThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_152getSLPDeflationThreshold[] = "NEP.getSLPDeflationThreshold(self)\n\n        Returns the threshold value that controls deflation.\n\n        Returns\n        -------\n        deftol: float\n                The threshold value.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_153getSLPDeflationThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSLPDeflationThreshold (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSLPDeflationThreshold", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSLPDeflationThreshold", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_152getSLPDeflationThreshold(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_152getSLPDeflationThreshold(struct PySlepcNEPObject *__pyx_v_self) {
  PetscReal __pyx_v_rval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSLPDeflationThreshold", 0);

  /* "SLEPc/NEP.pyx":1357
 *                 The threshold value.
 *         """
 *         cdef PetscReal rval = 0.0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSLPGetDeflationThreshold(self.nep, &rval) )
 *         return toReal(rval)
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/NEP.pyx":1358
 *         """
 *         cdef PetscReal rval = 0.0
 *         CHKERR( NEPSLPGetDeflationThreshold(self.nep, &rval) )             # <<<<<<<<<<<<<<
 *         return toReal(rval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSLPGetDeflationThreshold(__pyx_v_self->nep, (&__pyx_v_rval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1358, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1359
 *         cdef PetscReal rval = 0.0
 *         CHKERR( NEPSLPGetDeflationThreshold(self.nep, &rval) )
 *         return toReal(rval)             # <<<<<<<<<<<<<<
 * 
 *     def setSLPEPS(self, EPS eps):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1359, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1348
 *         CHKERR( NEPSLPSetDeflationThreshold(self.nep, val) )
 * 
 *     def getSLPDeflationThreshold(self):             # <<<<<<<<<<<<<<
 *         """
 *         Returns the threshold value that controls deflation.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getSLPDeflationThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1361
 *         return toReal(rval)
 * 
 *     def setSLPEPS(self, EPS eps):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a linear eigensolver object to the nonlinear eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_155setSLPEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_154setSLPEPS[] = "NEP.setSLPEPS(self, EPS eps)\n\n        Associate a linear eigensolver object to the nonlinear eigensolver.\n\n        Parameters\n        ----------\n        eps: `EPS`\n             The linear eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_155setSLPEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcEPSObject *__pyx_v_eps = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSLPEPS (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_eps,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_eps)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSLPEPS") < 0)) __PYX_ERR(20, 1361, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_eps = ((struct PySlepcEPSObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSLPEPS", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1361, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setSLPEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_eps), __pyx_ptype_8slepc4py_5SLEPc_EPS, 0, "eps", 0))) __PYX_ERR(20, 1361, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_154setSLPEPS(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_eps);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_154setSLPEPS(struct PySlepcNEPObject *__pyx_v_self, struct PySlepcEPSObject *__pyx_v_eps) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSLPEPS", 0);

  /* "SLEPc/NEP.pyx":1370
 *              The linear eigensolver.
 *         """
 *         CHKERR( NEPSLPSetEPS(self.nep, eps.eps) )             # <<<<<<<<<<<<<<
 * 
 *     def getSLPEPS(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSLPSetEPS(__pyx_v_self->nep, __pyx_v_eps->eps)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1370, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1361
 *         return toReal(rval)
 * 
 *     def setSLPEPS(self, EPS eps):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a linear eigensolver object to the nonlinear eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setSLPEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1372
 *         CHKERR( NEPSLPSetEPS(self.nep, eps.eps) )
 * 
 *     def getSLPEPS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the linear eigensolver object associated with the nonlinear eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_157getSLPEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_156getSLPEPS[] = "NEP.getSLPEPS(self)\n\n        Retrieve the linear eigensolver object associated with the nonlinear eigensolver.\n\n        Returns\n        -------\n        eps: `EPS`\n             The linear eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_157getSLPEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSLPEPS (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSLPEPS", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSLPEPS", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_156getSLPEPS(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_156getSLPEPS(struct PySlepcNEPObject *__pyx_v_self) {
  struct PySlepcEPSObject *__pyx_v_eps = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSLPEPS", 0);

  /* "SLEPc/NEP.pyx":1381
 *              The linear eigensolver.
 *         """
 *         cdef EPS eps = EPS()             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSLPGetEPS(self.nep, &eps.eps) )
 *         PetscINCREF(eps.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1381, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_eps = ((struct PySlepcEPSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1382
 *         """
 *         cdef EPS eps = EPS()
 *         CHKERR( NEPSLPGetEPS(self.nep, &eps.eps) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(eps.obj)
 *         return eps
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSLPGetEPS(__pyx_v_self->nep, (&__pyx_v_eps->eps))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1382, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1383
 *         cdef EPS eps = EPS()
 *         CHKERR( NEPSLPGetEPS(self.nep, &eps.eps) )
 *         PetscINCREF(eps.obj)             # <<<<<<<<<<<<<<
 *         return eps
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_eps->__pyx_base.obj));

  /* "SLEPc/NEP.pyx":1384
 *         CHKERR( NEPSLPGetEPS(self.nep, &eps.eps) )
 *         PetscINCREF(eps.obj)
 *         return eps             # <<<<<<<<<<<<<<
 * 
 *     def setSLPEPSLeft(self, EPS eps):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_eps));
  __pyx_r = ((PyObject *)__pyx_v_eps);
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1372
 *         CHKERR( NEPSLPSetEPS(self.nep, eps.eps) )
 * 
 *     def getSLPEPS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the linear eigensolver object associated with the nonlinear eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getSLPEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_eps);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1386
 *         return eps
 * 
 *     def setSLPEPSLeft(self, EPS eps):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a linear eigensolver object to the nonlinear eigensolver,
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_159setSLPEPSLeft(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_158setSLPEPSLeft[] = "NEP.setSLPEPSLeft(self, EPS eps)\n\n        Associate a linear eigensolver object to the nonlinear eigensolver,\n        used to compute left eigenvectors in the two-sided variant of SLP.\n\n        Parameters\n        ----------\n        eps: `EPS`\n             The linear eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_159setSLPEPSLeft(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcEPSObject *__pyx_v_eps = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSLPEPSLeft (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_eps,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_eps)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSLPEPSLeft") < 0)) __PYX_ERR(20, 1386, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_eps = ((struct PySlepcEPSObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSLPEPSLeft", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1386, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setSLPEPSLeft", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_eps), __pyx_ptype_8slepc4py_5SLEPc_EPS, 0, "eps", 0))) __PYX_ERR(20, 1386, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_158setSLPEPSLeft(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_eps);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_158setSLPEPSLeft(struct PySlepcNEPObject *__pyx_v_self, struct PySlepcEPSObject *__pyx_v_eps) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSLPEPSLeft", 0);

  /* "SLEPc/NEP.pyx":1396
 *              The linear eigensolver.
 *         """
 *         CHKERR( NEPSLPSetEPSLeft(self.nep, eps.eps) )             # <<<<<<<<<<<<<<
 * 
 *     def getSLPEPSLeft(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSLPSetEPSLeft(__pyx_v_self->nep, __pyx_v_eps->eps)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1396, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1386
 *         return eps
 * 
 *     def setSLPEPSLeft(self, EPS eps):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a linear eigensolver object to the nonlinear eigensolver,
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setSLPEPSLeft", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1398
 *         CHKERR( NEPSLPSetEPSLeft(self.nep, eps.eps) )
 * 
 *     def getSLPEPSLeft(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the left eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_161getSLPEPSLeft(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_160getSLPEPSLeft[] = "NEP.getSLPEPSLeft(self)\n\n        Retrieve the left eigensolver.\n\n        Returns\n        -------\n        eps: `EPS`\n             The linear eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_161getSLPEPSLeft(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSLPEPSLeft (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSLPEPSLeft", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSLPEPSLeft", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_160getSLPEPSLeft(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_160getSLPEPSLeft(struct PySlepcNEPObject *__pyx_v_self) {
  struct PySlepcEPSObject *__pyx_v_eps = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSLPEPSLeft", 0);

  /* "SLEPc/NEP.pyx":1407
 *              The linear eigensolver.
 *         """
 *         cdef EPS eps = EPS()             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSLPGetEPSLeft(self.nep, &eps.eps) )
 *         PetscINCREF(eps.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1407, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_eps = ((struct PySlepcEPSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1408
 *         """
 *         cdef EPS eps = EPS()
 *         CHKERR( NEPSLPGetEPSLeft(self.nep, &eps.eps) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(eps.obj)
 *         return eps
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSLPGetEPSLeft(__pyx_v_self->nep, (&__pyx_v_eps->eps))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1408, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1409
 *         cdef EPS eps = EPS()
 *         CHKERR( NEPSLPGetEPSLeft(self.nep, &eps.eps) )
 *         PetscINCREF(eps.obj)             # <<<<<<<<<<<<<<
 *         return eps
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_eps->__pyx_base.obj));

  /* "SLEPc/NEP.pyx":1410
 *         CHKERR( NEPSLPGetEPSLeft(self.nep, &eps.eps) )
 *         PetscINCREF(eps.obj)
 *         return eps             # <<<<<<<<<<<<<<
 * 
 *     def setSLPKSP(self, KSP ksp):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_eps));
  __pyx_r = ((PyObject *)__pyx_v_eps);
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1398
 *         CHKERR( NEPSLPSetEPSLeft(self.nep, eps.eps) )
 * 
 *     def getSLPEPSLeft(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the left eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getSLPEPSLeft", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_eps);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1412
 *         return eps
 * 
 *     def setSLPKSP(self, KSP ksp):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a linear solver object to the nonlinear eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_163setSLPKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_162setSLPKSP[] = "NEP.setSLPKSP(self, KSP ksp)\n\n        Associate a linear solver object to the nonlinear eigensolver.\n\n        Parameters\n        ----------\n        ksp: `KSP`\n             The linear solver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_163setSLPKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscKSPObject *__pyx_v_ksp = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setSLPKSP (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ksp,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ksp)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setSLPKSP") < 0)) __PYX_ERR(20, 1412, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_ksp = ((struct PyPetscKSPObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setSLPKSP", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1412, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setSLPKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ksp), __pyx_ptype_8petsc4py_5PETSc_KSP, 0, "ksp", 0))) __PYX_ERR(20, 1412, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_162setSLPKSP(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_ksp);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_162setSLPKSP(struct PySlepcNEPObject *__pyx_v_self, struct PyPetscKSPObject *__pyx_v_ksp) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setSLPKSP", 0);

  /* "SLEPc/NEP.pyx":1421
 *              The linear solver object.
 *         """
 *         CHKERR( NEPSLPSetKSP(self.nep, ksp.ksp) )             # <<<<<<<<<<<<<<
 * 
 *     def getSLPKSP(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSLPSetKSP(__pyx_v_self->nep, __pyx_v_ksp->ksp)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1421, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1412
 *         return eps
 * 
 *     def setSLPKSP(self, KSP ksp):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a linear solver object to the nonlinear eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setSLPKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1423
 *         CHKERR( NEPSLPSetKSP(self.nep, ksp.ksp) )
 * 
 *     def getSLPKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the linear solver object associated with the nonlinear eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_165getSLPKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_164getSLPKSP[] = "NEP.getSLPKSP(self)\n\n        Retrieve the linear solver object associated with the nonlinear eigensolver.\n\n        Returns\n        -------\n        ksp: `KSP`\n             The linear solver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_165getSLPKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getSLPKSP (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getSLPKSP", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSLPKSP", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_164getSLPKSP(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_164getSLPKSP(struct PySlepcNEPObject *__pyx_v_self) {
  struct PyPetscKSPObject *__pyx_v_ksp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getSLPKSP", 0);

  /* "SLEPc/NEP.pyx":1432
 *              The linear solver object.
 *         """
 *         cdef KSP ksp = KSP()             # <<<<<<<<<<<<<<
 *         CHKERR( NEPSLPGetKSP(self.nep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_KSP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1432, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ksp = ((struct PyPetscKSPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1433
 *         """
 *         cdef KSP ksp = KSP()
 *         CHKERR( NEPSLPGetKSP(self.nep, &ksp.ksp) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(ksp.obj)
 *         return ksp
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPSLPGetKSP(__pyx_v_self->nep, (&__pyx_v_ksp->ksp))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1433, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1434
 *         cdef KSP ksp = KSP()
 *         CHKERR( NEPSLPGetKSP(self.nep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)             # <<<<<<<<<<<<<<
 *         return ksp
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ksp->__pyx_base.obj));

  /* "SLEPc/NEP.pyx":1435
 *         CHKERR( NEPSLPGetKSP(self.nep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 *         return ksp             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ksp));
  __pyx_r = ((PyObject *)__pyx_v_ksp);
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1423
 *         CHKERR( NEPSLPSetKSP(self.nep, ksp.ksp) )
 * 
 *     def getSLPKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the linear solver object associated with the nonlinear eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getSLPKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ksp);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1439
 *     #
 * 
 *     def setNArnoldiKSP(self, KSP ksp):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a linear solver object to the nonlinear eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_167setNArnoldiKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_166setNArnoldiKSP[] = "NEP.setNArnoldiKSP(self, KSP ksp)\n\n        Associate a linear solver object to the nonlinear eigensolver.\n\n        Parameters\n        ----------\n        ksp: `KSP`\n             The linear solver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_167setNArnoldiKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscKSPObject *__pyx_v_ksp = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setNArnoldiKSP (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ksp,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ksp)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNArnoldiKSP") < 0)) __PYX_ERR(20, 1439, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_ksp = ((struct PyPetscKSPObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setNArnoldiKSP", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1439, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNArnoldiKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ksp), __pyx_ptype_8petsc4py_5PETSc_KSP, 0, "ksp", 0))) __PYX_ERR(20, 1439, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_166setNArnoldiKSP(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_ksp);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_166setNArnoldiKSP(struct PySlepcNEPObject *__pyx_v_self, struct PyPetscKSPObject *__pyx_v_ksp) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setNArnoldiKSP", 0);

  /* "SLEPc/NEP.pyx":1448
 *              The linear solver object.
 *         """
 *         CHKERR( NEPNArnoldiSetKSP(self.nep, ksp.ksp) )             # <<<<<<<<<<<<<<
 * 
 *     def getNArnoldiKSP(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNArnoldiSetKSP(__pyx_v_self->nep, __pyx_v_ksp->ksp)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1448, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1439
 *     #
 * 
 *     def setNArnoldiKSP(self, KSP ksp):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a linear solver object to the nonlinear eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNArnoldiKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1450
 *         CHKERR( NEPNArnoldiSetKSP(self.nep, ksp.ksp) )
 * 
 *     def getNArnoldiKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the linear solver object associated with the nonlinear eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_169getNArnoldiKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_168getNArnoldiKSP[] = "NEP.getNArnoldiKSP(self)\n\n        Retrieve the linear solver object associated with the nonlinear eigensolver.\n\n        Returns\n        -------\n        ksp: `KSP`\n             The linear solver object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_169getNArnoldiKSP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getNArnoldiKSP (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getNArnoldiKSP", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNArnoldiKSP", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_168getNArnoldiKSP(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_168getNArnoldiKSP(struct PySlepcNEPObject *__pyx_v_self) {
  struct PyPetscKSPObject *__pyx_v_ksp = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getNArnoldiKSP", 0);

  /* "SLEPc/NEP.pyx":1459
 *              The linear solver object.
 *         """
 *         cdef KSP ksp = KSP()             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNArnoldiGetKSP(self.nep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_KSP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1459, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ksp = ((struct PyPetscKSPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1460
 *         """
 *         cdef KSP ksp = KSP()
 *         CHKERR( NEPNArnoldiGetKSP(self.nep, &ksp.ksp) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(ksp.obj)
 *         return ksp
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNArnoldiGetKSP(__pyx_v_self->nep, (&__pyx_v_ksp->ksp))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1460, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1461
 *         cdef KSP ksp = KSP()
 *         CHKERR( NEPNArnoldiGetKSP(self.nep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)             # <<<<<<<<<<<<<<
 *         return ksp
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_ksp->__pyx_base.obj));

  /* "SLEPc/NEP.pyx":1462
 *         CHKERR( NEPNArnoldiGetKSP(self.nep, &ksp.ksp) )
 *         PetscINCREF(ksp.obj)
 *         return ksp             # <<<<<<<<<<<<<<
 * 
 *     def setNArnoldiLagPreconditioner(self, lag):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ksp));
  __pyx_r = ((PyObject *)__pyx_v_ksp);
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1450
 *         CHKERR( NEPNArnoldiSetKSP(self.nep, ksp.ksp) )
 * 
 *     def getNArnoldiKSP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the linear solver object associated with the nonlinear eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getNArnoldiKSP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ksp);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1464
 *         return ksp
 * 
 *     def setNArnoldiLagPreconditioner(self, lag):             # <<<<<<<<<<<<<<
 *         """
 *         Determines when the preconditioner is rebuilt in the nonlinear solve.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_171setNArnoldiLagPreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_170setNArnoldiLagPreconditioner[] = "NEP.setNArnoldiLagPreconditioner(self, lag)\n\n        Determines when the preconditioner is rebuilt in the nonlinear solve.\n\n        Parameters\n        ----------\n        lag: int\n             0 indicates NEVER rebuild, 1 means rebuild every time the Jacobian is\n             computed within the nonlinear iteration, 2 means every second time\n             the Jacobian is built, etc.\n\n        Notes\n        -----\n        The default is 1. The preconditioner is ALWAYS built in the first\n        iteration of a nonlinear solve.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_171setNArnoldiLagPreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_lag = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setNArnoldiLagPreconditioner (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lag,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lag)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNArnoldiLagPreconditioner") < 0)) __PYX_ERR(20, 1464, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_lag = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setNArnoldiLagPreconditioner", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1464, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNArnoldiLagPreconditioner", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_170setNArnoldiLagPreconditioner(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_lag);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_170setNArnoldiLagPreconditioner(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_lag) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setNArnoldiLagPreconditioner", 0);

  /* "SLEPc/NEP.pyx":1480
 *         iteration of a nonlinear solve.
 *         """
 *         cdef PetscInt ival = asInt(lag)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNArnoldiSetLagPreconditioner(self.nep, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_lag); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 1480, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/NEP.pyx":1481
 *         """
 *         cdef PetscInt ival = asInt(lag)
 *         CHKERR( NEPNArnoldiSetLagPreconditioner(self.nep, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getNArnoldiLagPreconditioner(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNArnoldiSetLagPreconditioner(__pyx_v_self->nep, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1481, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1464
 *         return ksp
 * 
 *     def setNArnoldiLagPreconditioner(self, lag):             # <<<<<<<<<<<<<<
 *         """
 *         Determines when the preconditioner is rebuilt in the nonlinear solve.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNArnoldiLagPreconditioner", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1483
 *         CHKERR( NEPNArnoldiSetLagPreconditioner(self.nep, ival) )
 * 
 *     def getNArnoldiLagPreconditioner(self):             # <<<<<<<<<<<<<<
 *         """
 *         Indicates how often the preconditioner is rebuilt.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_173getNArnoldiLagPreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_172getNArnoldiLagPreconditioner[] = "NEP.getNArnoldiLagPreconditioner(self)\n\n        Indicates how often the preconditioner is rebuilt.\n\n        Returns\n        -------\n        lag: int\n             The lag parameter.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_173getNArnoldiLagPreconditioner(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getNArnoldiLagPreconditioner (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getNArnoldiLagPreconditioner", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNArnoldiLagPreconditioner", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_172getNArnoldiLagPreconditioner(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_172getNArnoldiLagPreconditioner(struct PySlepcNEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getNArnoldiLagPreconditioner", 0);

  /* "SLEPc/NEP.pyx":1492
 *              The lag parameter.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNArnoldiGetLagPreconditioner(self.nep, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/NEP.pyx":1493
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( NEPNArnoldiGetLagPreconditioner(self.nep, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNArnoldiGetLagPreconditioner(__pyx_v_self->nep, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1493, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1494
 *         cdef PetscInt ival = 0
 *         CHKERR( NEPNArnoldiGetLagPreconditioner(self.nep, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1494, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1483
 *         CHKERR( NEPNArnoldiSetLagPreconditioner(self.nep, ival) )
 * 
 *     def getNArnoldiLagPreconditioner(self):             # <<<<<<<<<<<<<<
 *         """
 *         Indicates how often the preconditioner is rebuilt.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getNArnoldiLagPreconditioner", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1498
 *     #
 * 
 *     def setInterpolPEP(self, PEP pep):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a polynomial eigensolver object to the nonlinear eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_175setInterpolPEP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_174setInterpolPEP[] = "NEP.setInterpolPEP(self, PEP pep)\n\n        Associate a polynomial eigensolver object to the nonlinear eigensolver.\n\n        Parameters\n        ----------\n        pep: `PEP`\n             The polynomial eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_175setInterpolPEP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcPEPObject *__pyx_v_pep = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setInterpolPEP (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pep,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pep)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setInterpolPEP") < 0)) __PYX_ERR(20, 1498, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_pep = ((struct PySlepcPEPObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setInterpolPEP", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1498, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setInterpolPEP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pep), __pyx_ptype_8slepc4py_5SLEPc_PEP, 0, "pep", 0))) __PYX_ERR(20, 1498, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_174setInterpolPEP(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_pep);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_174setInterpolPEP(struct PySlepcNEPObject *__pyx_v_self, struct PySlepcPEPObject *__pyx_v_pep) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setInterpolPEP", 0);

  /* "SLEPc/NEP.pyx":1507
 *              The polynomial eigensolver.
 *         """
 *         CHKERR( NEPInterpolSetPEP(self.nep, pep.pep) )             # <<<<<<<<<<<<<<
 * 
 *     def getInterpolPEP(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPInterpolSetPEP(__pyx_v_self->nep, __pyx_v_pep->pep)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1507, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1498
 *     #
 * 
 *     def setInterpolPEP(self, PEP pep):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a polynomial eigensolver object to the nonlinear eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setInterpolPEP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1509
 *         CHKERR( NEPInterpolSetPEP(self.nep, pep.pep) )
 * 
 *     def getInterpolPEP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the polynomial eigensolver object associated with the nonlinear eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_177getInterpolPEP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_176getInterpolPEP[] = "NEP.getInterpolPEP(self)\n\n        Retrieve the polynomial eigensolver object associated with the nonlinear eigensolver.\n\n        Returns\n        -------\n        pep: `PEP`\n             The polynomial eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_177getInterpolPEP(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getInterpolPEP (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getInterpolPEP", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getInterpolPEP", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_176getInterpolPEP(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_176getInterpolPEP(struct PySlepcNEPObject *__pyx_v_self) {
  struct PySlepcPEPObject *__pyx_v_pep = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getInterpolPEP", 0);

  /* "SLEPc/NEP.pyx":1518
 *              The polynomial eigensolver.
 *         """
 *         cdef PEP pep = PEP()             # <<<<<<<<<<<<<<
 *         CHKERR( NEPInterpolGetPEP(self.nep, &pep.pep) )
 *         PetscINCREF(pep.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1518, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_pep = ((struct PySlepcPEPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1519
 *         """
 *         cdef PEP pep = PEP()
 *         CHKERR( NEPInterpolGetPEP(self.nep, &pep.pep) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(pep.obj)
 *         return pep
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPInterpolGetPEP(__pyx_v_self->nep, (&__pyx_v_pep->pep))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1519, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1520
 *         cdef PEP pep = PEP()
 *         CHKERR( NEPInterpolGetPEP(self.nep, &pep.pep) )
 *         PetscINCREF(pep.obj)             # <<<<<<<<<<<<<<
 *         return pep
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_pep->__pyx_base.obj));

  /* "SLEPc/NEP.pyx":1521
 *         CHKERR( NEPInterpolGetPEP(self.nep, &pep.pep) )
 *         PetscINCREF(pep.obj)
 *         return pep             # <<<<<<<<<<<<<<
 * 
 *     def setInterpolInterpolation(self, tol=None, deg=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_pep));
  __pyx_r = ((PyObject *)__pyx_v_pep);
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1509
 *         CHKERR( NEPInterpolSetPEP(self.nep, pep.pep) )
 * 
 *     def getInterpolPEP(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the polynomial eigensolver object associated with the nonlinear eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getInterpolPEP", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_pep);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1523
 *         return pep
 * 
 *     def setInterpolInterpolation(self, tol=None, deg=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance and maximum degree when building the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_179setInterpolInterpolation(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_178setInterpolInterpolation[] = "NEP.setInterpolInterpolation(self, tol=None, deg=None)\n\n        Sets the tolerance and maximum degree when building the\n        interpolation polynomial.\n\n        Parameters\n        ----------\n        tol: float, optional\n            The tolerance to stop computing polynomial coefficients.\n        deg: int, optional\n            The maximum degree of interpolation.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_179setInterpolInterpolation(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_tol = 0;
  PyObject *__pyx_v_deg = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setInterpolInterpolation (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_tol,&__pyx_n_s_deg,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tol);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_deg);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setInterpolInterpolation") < 0)) __PYX_ERR(20, 1523, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_tol = values[0];
    __pyx_v_deg = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setInterpolInterpolation", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1523, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setInterpolInterpolation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_178setInterpolInterpolation(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_tol, __pyx_v_deg);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_178setInterpolInterpolation(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_tol, PyObject *__pyx_v_deg) {
  PetscReal __pyx_v_rval;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscReal __pyx_t_3;
  PetscInt __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setInterpolInterpolation", 0);

  /* "SLEPc/NEP.pyx":1535
 *             The maximum degree of interpolation.
 *         """
 *         cdef PetscReal rval = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol is not None: rval = asReal(tol)
 */
  __pyx_v_rval = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":1536
 *         """
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if tol is not None: rval = asReal(tol)
 *         if deg is not None: ival = asInt(deg)
 */
  __pyx_v_ival = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":1537
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol is not None: rval = asReal(tol)             # <<<<<<<<<<<<<<
 *         if deg is not None: ival = asInt(deg)
 *         CHKERR( NEPInterpolSetInterpolation(self.nep, rval, ival) )
 */
  __pyx_t_1 = (__pyx_v_tol != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_tol); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(20, 1537, __pyx_L1_error)
    __pyx_v_rval = __pyx_t_3;
  }

  /* "SLEPc/NEP.pyx":1538
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol is not None: rval = asReal(tol)
 *         if deg is not None: ival = asInt(deg)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPInterpolSetInterpolation(self.nep, rval, ival) )
 * 
 */
  __pyx_t_2 = (__pyx_v_deg != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_deg); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 1538, __pyx_L1_error)
    __pyx_v_ival = __pyx_t_4;
  }

  /* "SLEPc/NEP.pyx":1539
 *         if tol is not None: rval = asReal(tol)
 *         if deg is not None: ival = asInt(deg)
 *         CHKERR( NEPInterpolSetInterpolation(self.nep, rval, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getInterpolInterpolation(self):
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPInterpolSetInterpolation(__pyx_v_self->nep, __pyx_v_rval, __pyx_v_ival)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(20, 1539, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1523
 *         return pep
 * 
 *     def setInterpolInterpolation(self, tol=None, deg=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance and maximum degree when building the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setInterpolInterpolation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1541
 *         CHKERR( NEPInterpolSetInterpolation(self.nep, rval, ival) )
 * 
 *     def getInterpolInterpolation(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance and maximum degree when building the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_181getInterpolInterpolation(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_180getInterpolInterpolation[] = "NEP.getInterpolInterpolation(self)\n\n        Gets the tolerance and maximum degree when building the\n        interpolation polynomial.\n\n        Returns\n        -------\n        tol: float\n            The tolerance to stop computing polynomial coefficients.\n        deg: int\n            The maximum degree of interpolation.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_181getInterpolInterpolation(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getInterpolInterpolation (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getInterpolInterpolation", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getInterpolInterpolation", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_180getInterpolInterpolation(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_180getInterpolInterpolation(struct PySlepcNEPObject *__pyx_v_self) {
  PetscReal __pyx_v_rval;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getInterpolInterpolation", 0);

  /* "SLEPc/NEP.pyx":1553
 *             The maximum degree of interpolation.
 *         """
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = 0
 *         CHKERR( NEPInterpolGetInterpolation(self.nep, &rval, &ival) )
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/NEP.pyx":1554
 *         """
 *         cdef PetscReal rval = 0
 *         cdef PetscInt  ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPInterpolGetInterpolation(self.nep, &rval, &ival) )
 *         return (toReal(rval), toInt(ival))
 */
  __pyx_v_ival = 0;

  /* "SLEPc/NEP.pyx":1555
 *         cdef PetscReal rval = 0
 *         cdef PetscInt  ival = 0
 *         CHKERR( NEPInterpolGetInterpolation(self.nep, &rval, &ival) )             # <<<<<<<<<<<<<<
 *         return (toReal(rval), toInt(ival))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPInterpolGetInterpolation(__pyx_v_self->nep, (&__pyx_v_rval), (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1555, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1556
 *         cdef PetscInt  ival = 0
 *         CHKERR( NEPInterpolGetInterpolation(self.nep, &rval, &ival) )
 *         return (toReal(rval), toInt(ival))             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1556, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1556, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 1556, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1541
 *         CHKERR( NEPInterpolSetInterpolation(self.nep, rval, ival) )
 * 
 *     def getInterpolInterpolation(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance and maximum degree when building the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getInterpolInterpolation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1560
 *     #
 * 
 *     def setNLEIGSRestart(self, keep):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the restart parameter for the NLEIGS method, in
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_183setNLEIGSRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_182setNLEIGSRestart[] = "NEP.setNLEIGSRestart(self, keep)\n\n        Sets the restart parameter for the NLEIGS method, in\n        particular the proportion of basis vectors that must be kept\n        after restart.\n\n        Parameters\n        ----------\n        keep: float\n              The number of vectors to be kept at restart.\n\n        Notes\n        -----\n        Allowed values are in the range [0.1,0.9]. The default is 0.5.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_183setNLEIGSRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_keep = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setNLEIGSRestart (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_keep,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_keep)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNLEIGSRestart") < 0)) __PYX_ERR(20, 1560, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_keep = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setNLEIGSRestart", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1560, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNLEIGSRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_182setNLEIGSRestart(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_keep);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_182setNLEIGSRestart(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_keep) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscReal __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setNLEIGSRestart", 0);

  /* "SLEPc/NEP.pyx":1575
 *         Allowed values are in the range [0.1,0.9]. The default is 0.5.
 *         """
 *         cdef PetscReal val = asReal(keep)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNLEIGSSetRestart(self.nep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_keep); if (unlikely(__pyx_t_1 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(20, 1575, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/NEP.pyx":1576
 *         """
 *         cdef PetscReal val = asReal(keep)
 *         CHKERR( NEPNLEIGSSetRestart(self.nep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getNLEIGSRestart(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNLEIGSSetRestart(__pyx_v_self->nep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1576, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1560
 *     #
 * 
 *     def setNLEIGSRestart(self, keep):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the restart parameter for the NLEIGS method, in
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNLEIGSRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1578
 *         CHKERR( NEPNLEIGSSetRestart(self.nep, val) )
 * 
 *     def getNLEIGSRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the restart parameter used in the NLEIGS method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_185getNLEIGSRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_184getNLEIGSRestart[] = "NEP.getNLEIGSRestart(self)\n\n        Gets the restart parameter used in the NLEIGS method.\n\n        Returns\n        -------\n        keep: float\n              The number of vectors to be kept at restart.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_185getNLEIGSRestart(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getNLEIGSRestart (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getNLEIGSRestart", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNLEIGSRestart", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_184getNLEIGSRestart(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_184getNLEIGSRestart(struct PySlepcNEPObject *__pyx_v_self) {
  PetscReal __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getNLEIGSRestart", 0);

  /* "SLEPc/NEP.pyx":1587
 *               The number of vectors to be kept at restart.
 *         """
 *         cdef PetscReal val = 0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNLEIGSGetRestart(self.nep, &val) )
 *         return toReal(val)
 */
  __pyx_v_val = 0.0;

  /* "SLEPc/NEP.pyx":1588
 *         """
 *         cdef PetscReal val = 0
 *         CHKERR( NEPNLEIGSGetRestart(self.nep, &val) )             # <<<<<<<<<<<<<<
 *         return toReal(val)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNLEIGSGetRestart(__pyx_v_self->nep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1588, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1589
 *         cdef PetscReal val = 0
 *         CHKERR( NEPNLEIGSGetRestart(self.nep, &val) )
 *         return toReal(val)             # <<<<<<<<<<<<<<
 * 
 *     def setNLEIGSLocking(self, lock):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1589, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1578
 *         CHKERR( NEPNLEIGSSetRestart(self.nep, val) )
 * 
 *     def getNLEIGSRestart(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the restart parameter used in the NLEIGS method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getNLEIGSRestart", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1591
 *         return toReal(val)
 * 
 *     def setNLEIGSLocking(self, lock):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between locking and non-locking variants of the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_187setNLEIGSLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_186setNLEIGSLocking[] = "NEP.setNLEIGSLocking(self, lock)\n\n        Choose between locking and non-locking variants of the\n        NLEIGS method.\n\n        Parameters\n        ----------\n        lock: bool\n              True if the locking variant must be selected.\n\n        Notes\n        -----\n        The default is to lock converged eigenpairs when the method restarts.\n        This behaviour can be changed so that all directions are kept in the\n        working subspace even if already converged to working accuracy (the\n        non-locking variant).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_187setNLEIGSLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_lock = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setNLEIGSLocking (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lock,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lock)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNLEIGSLocking") < 0)) __PYX_ERR(20, 1591, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_lock = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setNLEIGSLocking", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1591, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNLEIGSLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_186setNLEIGSLocking(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_lock);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_186setNLEIGSLocking(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_lock) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setNLEIGSLocking", 0);

  /* "SLEPc/NEP.pyx":1608
 *         non-locking variant).
 *         """
 *         cdef PetscBool val = asBool(lock)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNLEIGSSetLocking(self.nep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_lock); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(20, 1608, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/NEP.pyx":1609
 *         """
 *         cdef PetscBool val = asBool(lock)
 *         CHKERR( NEPNLEIGSSetLocking(self.nep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getNLEIGSLocking(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNLEIGSSetLocking(__pyx_v_self->nep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1609, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1591
 *         return toReal(val)
 * 
 *     def setNLEIGSLocking(self, lock):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between locking and non-locking variants of the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNLEIGSLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1611
 *         CHKERR( NEPNLEIGSSetLocking(self.nep, val) )
 * 
 *     def getNLEIGSLocking(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the locking flag used in the NLEIGS method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_189getNLEIGSLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_188getNLEIGSLocking[] = "NEP.getNLEIGSLocking(self)\n\n        Gets the locking flag used in the NLEIGS method.\n\n        Returns\n        -------\n        lock: bool\n              The locking flag.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_189getNLEIGSLocking(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getNLEIGSLocking (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getNLEIGSLocking", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNLEIGSLocking", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_188getNLEIGSLocking(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_188getNLEIGSLocking(struct PySlepcNEPObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getNLEIGSLocking", 0);

  /* "SLEPc/NEP.pyx":1620
 *               The locking flag.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNLEIGSGetLocking(self.nep, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/NEP.pyx":1621
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( NEPNLEIGSGetLocking(self.nep, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNLEIGSGetLocking(__pyx_v_self->nep, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1621, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1622
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( NEPNLEIGSGetLocking(self.nep, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setNLEIGSInterpolation(self, tol=None, deg=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1622, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1611
 *         CHKERR( NEPNLEIGSSetLocking(self.nep, val) )
 * 
 *     def getNLEIGSLocking(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the locking flag used in the NLEIGS method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getNLEIGSLocking", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1624
 *         return toBool(tval)
 * 
 *     def setNLEIGSInterpolation(self, tol=None, deg=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance and maximum degree when building the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_191setNLEIGSInterpolation(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_190setNLEIGSInterpolation[] = "NEP.setNLEIGSInterpolation(self, tol=None, deg=None)\n\n        Sets the tolerance and maximum degree when building the\n        interpolation via divided differences.\n\n        Parameters\n        ----------\n        tol: float, optional\n            The tolerance to stop computing divided differences.\n        deg: int, optional\n            The maximum degree of interpolation.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_191setNLEIGSInterpolation(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_tol = 0;
  PyObject *__pyx_v_deg = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setNLEIGSInterpolation (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_tol,&__pyx_n_s_deg,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tol);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_deg);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNLEIGSInterpolation") < 0)) __PYX_ERR(20, 1624, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_tol = values[0];
    __pyx_v_deg = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setNLEIGSInterpolation", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1624, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNLEIGSInterpolation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_190setNLEIGSInterpolation(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_tol, __pyx_v_deg);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_190setNLEIGSInterpolation(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_tol, PyObject *__pyx_v_deg) {
  PetscReal __pyx_v_rval;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscReal __pyx_t_3;
  PetscInt __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setNLEIGSInterpolation", 0);

  /* "SLEPc/NEP.pyx":1636
 *             The maximum degree of interpolation.
 *         """
 *         cdef PetscReal rval = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol is not None: rval = asReal(tol)
 */
  __pyx_v_rval = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":1637
 *         """
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if tol is not None: rval = asReal(tol)
 *         if deg is not None: ival = asInt(deg)
 */
  __pyx_v_ival = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":1638
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol is not None: rval = asReal(tol)             # <<<<<<<<<<<<<<
 *         if deg is not None: ival = asInt(deg)
 *         CHKERR( NEPNLEIGSSetInterpolation(self.nep, rval, ival) )
 */
  __pyx_t_1 = (__pyx_v_tol != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_tol); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(20, 1638, __pyx_L1_error)
    __pyx_v_rval = __pyx_t_3;
  }

  /* "SLEPc/NEP.pyx":1639
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol is not None: rval = asReal(tol)
 *         if deg is not None: ival = asInt(deg)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNLEIGSSetInterpolation(self.nep, rval, ival) )
 * 
 */
  __pyx_t_2 = (__pyx_v_deg != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_deg); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 1639, __pyx_L1_error)
    __pyx_v_ival = __pyx_t_4;
  }

  /* "SLEPc/NEP.pyx":1640
 *         if tol is not None: rval = asReal(tol)
 *         if deg is not None: ival = asInt(deg)
 *         CHKERR( NEPNLEIGSSetInterpolation(self.nep, rval, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getNLEIGSInterpolation(self):
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNLEIGSSetInterpolation(__pyx_v_self->nep, __pyx_v_rval, __pyx_v_ival)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(20, 1640, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1624
 *         return toBool(tval)
 * 
 *     def setNLEIGSInterpolation(self, tol=None, deg=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance and maximum degree when building the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNLEIGSInterpolation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1642
 *         CHKERR( NEPNLEIGSSetInterpolation(self.nep, rval, ival) )
 * 
 *     def getNLEIGSInterpolation(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance and maximum degree when building the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_193getNLEIGSInterpolation(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_192getNLEIGSInterpolation[] = "NEP.getNLEIGSInterpolation(self)\n\n        Gets the tolerance and maximum degree when building the\n        interpolation via divided differences.\n\n        Returns\n        -------\n        tol: float\n            The tolerance to stop computing divided differences.\n        deg: int\n            The maximum degree of interpolation.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_193getNLEIGSInterpolation(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getNLEIGSInterpolation (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getNLEIGSInterpolation", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNLEIGSInterpolation", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_192getNLEIGSInterpolation(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_192getNLEIGSInterpolation(struct PySlepcNEPObject *__pyx_v_self) {
  PetscReal __pyx_v_rval;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getNLEIGSInterpolation", 0);

  /* "SLEPc/NEP.pyx":1654
 *             The maximum degree of interpolation.
 *         """
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = 0
 *         CHKERR( NEPNLEIGSGetInterpolation(self.nep, &rval, &ival) )
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/NEP.pyx":1655
 *         """
 *         cdef PetscReal rval = 0
 *         cdef PetscInt  ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNLEIGSGetInterpolation(self.nep, &rval, &ival) )
 *         return (toReal(rval), toInt(ival))
 */
  __pyx_v_ival = 0;

  /* "SLEPc/NEP.pyx":1656
 *         cdef PetscReal rval = 0
 *         cdef PetscInt  ival = 0
 *         CHKERR( NEPNLEIGSGetInterpolation(self.nep, &rval, &ival) )             # <<<<<<<<<<<<<<
 *         return (toReal(rval), toInt(ival))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNLEIGSGetInterpolation(__pyx_v_self->nep, (&__pyx_v_rval), (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1656, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1657
 *         cdef PetscInt  ival = 0
 *         CHKERR( NEPNLEIGSGetInterpolation(self.nep, &rval, &ival) )
 *         return (toReal(rval), toInt(ival))             # <<<<<<<<<<<<<<
 * 
 *     def setNLEIGSFullBasis(self, fullbasis=True):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1657, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1657, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 1657, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1642
 *         CHKERR( NEPNLEIGSSetInterpolation(self.nep, rval, ival) )
 * 
 *     def getNLEIGSInterpolation(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance and maximum degree when building the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getNLEIGSInterpolation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1659
 *         return (toReal(rval), toInt(ival))
 * 
 *     def setNLEIGSFullBasis(self, fullbasis=True):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between TOAR-basis (default) and full-basis variants
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_195setNLEIGSFullBasis(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_194setNLEIGSFullBasis[] = "NEP.setNLEIGSFullBasis(self, fullbasis=True)\n\n        Choose between TOAR-basis (default) and full-basis variants\n        of the NLEIGS method.\n\n        Parameters\n        ----------\n        fullbasis: bool\n              True if the full-basis variant must be selected.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_195setNLEIGSFullBasis(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_fullbasis = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setNLEIGSFullBasis (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fullbasis,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fullbasis);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNLEIGSFullBasis") < 0)) __PYX_ERR(20, 1659, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_fullbasis = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setNLEIGSFullBasis", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1659, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNLEIGSFullBasis", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_194setNLEIGSFullBasis(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_fullbasis);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_194setNLEIGSFullBasis(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_fullbasis) {
  PetscBool __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setNLEIGSFullBasis", 0);

  /* "SLEPc/NEP.pyx":1669
 *               True if the full-basis variant must be selected.
 *         """
 *         cdef PetscBool val = asBool(fullbasis)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNLEIGSSetFullBasis(self.nep, val) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_fullbasis); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(20, 1669, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/NEP.pyx":1670
 *         """
 *         cdef PetscBool val = asBool(fullbasis)
 *         CHKERR( NEPNLEIGSSetFullBasis(self.nep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getNLEIGSFullBasis(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNLEIGSSetFullBasis(__pyx_v_self->nep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1670, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1659
 *         return (toReal(rval), toInt(ival))
 * 
 *     def setNLEIGSFullBasis(self, fullbasis=True):             # <<<<<<<<<<<<<<
 *         """
 *         Choose between TOAR-basis (default) and full-basis variants
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNLEIGSFullBasis", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1672
 *         CHKERR( NEPNLEIGSSetFullBasis(self.nep, val) )
 * 
 *     def getNLEIGSFullBasis(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the flag that indicates if NLEIGS is using the full-basis variant.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_197getNLEIGSFullBasis(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_196getNLEIGSFullBasis[] = "NEP.getNLEIGSFullBasis(self)\n\n        Gets the flag that indicates if NLEIGS is using the full-basis variant.\n\n        Returns\n        -------\n        fullbasis: bool\n              True if the full-basis variant must be selected.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_197getNLEIGSFullBasis(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getNLEIGSFullBasis (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getNLEIGSFullBasis", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNLEIGSFullBasis", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_196getNLEIGSFullBasis(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_196getNLEIGSFullBasis(struct PySlepcNEPObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getNLEIGSFullBasis", 0);

  /* "SLEPc/NEP.pyx":1681
 *               True if the full-basis variant must be selected.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNLEIGSGetFullBasis(self.nep, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/NEP.pyx":1682
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( NEPNLEIGSGetFullBasis(self.nep, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNLEIGSGetFullBasis(__pyx_v_self->nep, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1682, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1683
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( NEPNLEIGSGetFullBasis(self.nep, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     def setNLEIGSEPS(self, EPS eps):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1683, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1672
 *         CHKERR( NEPNLEIGSSetFullBasis(self.nep, val) )
 * 
 *     def getNLEIGSFullBasis(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the flag that indicates if NLEIGS is using the full-basis variant.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getNLEIGSFullBasis", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1685
 *         return toBool(tval)
 * 
 *     def setNLEIGSEPS(self, EPS eps):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a linear eigensolver object to the nonlinear eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_199setNLEIGSEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_198setNLEIGSEPS[] = "NEP.setNLEIGSEPS(self, EPS eps)\n\n        Associate a linear eigensolver object to the nonlinear eigensolver.\n\n        Parameters\n        ----------\n        eps: `EPS`\n             The linear eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_199setNLEIGSEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcEPSObject *__pyx_v_eps = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setNLEIGSEPS (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_eps,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_eps)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNLEIGSEPS") < 0)) __PYX_ERR(20, 1685, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_eps = ((struct PySlepcEPSObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setNLEIGSEPS", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1685, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNLEIGSEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_eps), __pyx_ptype_8slepc4py_5SLEPc_EPS, 0, "eps", 0))) __PYX_ERR(20, 1685, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_198setNLEIGSEPS(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_eps);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_198setNLEIGSEPS(struct PySlepcNEPObject *__pyx_v_self, struct PySlepcEPSObject *__pyx_v_eps) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setNLEIGSEPS", 0);

  /* "SLEPc/NEP.pyx":1694
 *              The linear eigensolver.
 *         """
 *         CHKERR( NEPNLEIGSSetEPS(self.nep, eps.eps) )             # <<<<<<<<<<<<<<
 * 
 *     def getNLEIGSEPS(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNLEIGSSetEPS(__pyx_v_self->nep, __pyx_v_eps->eps)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1694, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1685
 *         return toBool(tval)
 * 
 *     def setNLEIGSEPS(self, EPS eps):             # <<<<<<<<<<<<<<
 *         """
 *         Associate a linear eigensolver object to the nonlinear eigensolver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNLEIGSEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1696
 *         CHKERR( NEPNLEIGSSetEPS(self.nep, eps.eps) )
 * 
 *     def getNLEIGSEPS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the linear eigensolver object associated with the nonlinear eigensolver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_201getNLEIGSEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_200getNLEIGSEPS[] = "NEP.getNLEIGSEPS(self)\n\n        Retrieve the linear eigensolver object associated with the nonlinear eigensolver.\n\n        Returns\n        -------\n        eps: `EPS`\n             The linear eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_201getNLEIGSEPS(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getNLEIGSEPS (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getNLEIGSEPS", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNLEIGSEPS", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_200getNLEIGSEPS(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_200getNLEIGSEPS(struct PySlepcNEPObject *__pyx_v_self) {
  struct PySlepcEPSObject *__pyx_v_eps = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getNLEIGSEPS", 0);

  /* "SLEPc/NEP.pyx":1705
 *              The linear eigensolver.
 *         """
 *         cdef EPS eps = EPS()             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNLEIGSGetEPS(self.nep, &eps.eps) )
 *         PetscINCREF(eps.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS)); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1705, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_eps = ((struct PySlepcEPSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1706
 *         """
 *         cdef EPS eps = EPS()
 *         CHKERR( NEPNLEIGSGetEPS(self.nep, &eps.eps) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(eps.obj)
 *         return eps
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNLEIGSGetEPS(__pyx_v_self->nep, (&__pyx_v_eps->eps))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1706, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1707
 *         cdef EPS eps = EPS()
 *         CHKERR( NEPNLEIGSGetEPS(self.nep, &eps.eps) )
 *         PetscINCREF(eps.obj)             # <<<<<<<<<<<<<<
 *         return eps
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_eps->__pyx_base.obj));

  /* "SLEPc/NEP.pyx":1708
 *         CHKERR( NEPNLEIGSGetEPS(self.nep, &eps.eps) )
 *         PetscINCREF(eps.obj)
 *         return eps             # <<<<<<<<<<<<<<
 * 
 *     def setNLEIGSRKShifts(self, shifts):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_eps));
  __pyx_r = ((PyObject *)__pyx_v_eps);
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1696
 *         CHKERR( NEPNLEIGSSetEPS(self.nep, eps.eps) )
 * 
 *     def getNLEIGSEPS(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the linear eigensolver object associated with the nonlinear eigensolver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getNLEIGSEPS", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_eps);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1710
 *         return eps
 * 
 *     def setNLEIGSRKShifts(self, shifts):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a list of shifts to be used in the Rational Krylov method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_203setNLEIGSRKShifts(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_202setNLEIGSRKShifts[] = "NEP.setNLEIGSRKShifts(self, shifts)\n\n        Sets a list of shifts to be used in the Rational Krylov method.\n\n        Parameters\n        ----------\n        shifts: array of scalars\n            Values specifying the shifts.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_203setNLEIGSRKShifts(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_shifts = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setNLEIGSRKShifts (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shifts,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shifts)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setNLEIGSRKShifts") < 0)) __PYX_ERR(20, 1710, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_shifts = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setNLEIGSRKShifts", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1710, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNLEIGSRKShifts", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_202setNLEIGSRKShifts(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_shifts);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_202setNLEIGSRKShifts(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_shifts) {
  PetscInt __pyx_v_na;
  PetscScalar *__pyx_v_a;
  CYTHON_UNUSED PyObject *__pyx_v_tmp1 = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setNLEIGSRKShifts", 0);

  /* "SLEPc/NEP.pyx":1719
 *             Values specifying the shifts.
 *         """
 *         cdef PetscInt na = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar *a = NULL
 *         cdef object tmp1 = iarray_s(shifts, &na, &a)
 */
  __pyx_v_na = 0;

  /* "SLEPc/NEP.pyx":1720
 *         """
 *         cdef PetscInt na = 0
 *         cdef PetscScalar *a = NULL             # <<<<<<<<<<<<<<
 *         cdef object tmp1 = iarray_s(shifts, &na, &a)
 *         CHKERR( NEPNLEIGSSetRKShifts(self.nep, na, a) )
 */
  __pyx_v_a = NULL;

  /* "SLEPc/NEP.pyx":1721
 *         cdef PetscInt na = 0
 *         cdef PetscScalar *a = NULL
 *         cdef object tmp1 = iarray_s(shifts, &na, &a)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNLEIGSSetRKShifts(self.nep, na, a) )
 * 
 */
  __pyx_t_1 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_iarray_s(__pyx_v_shifts, (&__pyx_v_na), (&__pyx_v_a))); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1721, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_tmp1 = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1722
 *         cdef PetscScalar *a = NULL
 *         cdef object tmp1 = iarray_s(shifts, &na, &a)
 *         CHKERR( NEPNLEIGSSetRKShifts(self.nep, na, a) )             # <<<<<<<<<<<<<<
 * 
 *     def getNLEIGSRKShifts(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNLEIGSSetRKShifts(__pyx_v_self->nep, __pyx_v_na, __pyx_v_a)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1722, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1710
 *         return eps
 * 
 *     def setNLEIGSRKShifts(self, shifts):             # <<<<<<<<<<<<<<
 *         """
 *         Sets a list of shifts to be used in the Rational Krylov method.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setNLEIGSRKShifts", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_tmp1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1724
 *         CHKERR( NEPNLEIGSSetRKShifts(self.nep, na, a) )
 * 
 *     def getNLEIGSRKShifts(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the list of shifts used in the Rational Krylov method.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_205getNLEIGSRKShifts(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_204getNLEIGSRKShifts[] = "NEP.getNLEIGSRKShifts(self)\n\n        Gets the list of shifts used in the Rational Krylov method.\n\n        Returns\n        -------\n        shifts: array of scalars\n            The shift values.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_205getNLEIGSRKShifts(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getNLEIGSRKShifts (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getNLEIGSRKShifts", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNLEIGSRKShifts", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_204getNLEIGSRKShifts(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_204getNLEIGSRKShifts(struct PySlepcNEPObject *__pyx_v_self) {
  PetscInt __pyx_v_np;
  PetscScalar *__pyx_v_coeff;
  PyObject *__pyx_v_ocoeff = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  char const *__pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  PyObject *__pyx_t_10 = NULL;
  int __pyx_t_11;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getNLEIGSRKShifts", 0);

  /* "SLEPc/NEP.pyx":1733
 *             The shift values.
 *         """
 *         cdef PetscInt np = 0             # <<<<<<<<<<<<<<
 *         cdef PetscScalar *coeff = NULL
 *         CHKERR( NEPNLEIGSGetRKShifts(self.nep, &np, &coeff) )
 */
  __pyx_v_np = 0;

  /* "SLEPc/NEP.pyx":1734
 *         """
 *         cdef PetscInt np = 0
 *         cdef PetscScalar *coeff = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNLEIGSGetRKShifts(self.nep, &np, &coeff) )
 *         cdef object ocoeff = None
 */
  __pyx_v_coeff = NULL;

  /* "SLEPc/NEP.pyx":1735
 *         cdef PetscInt np = 0
 *         cdef PetscScalar *coeff = NULL
 *         CHKERR( NEPNLEIGSGetRKShifts(self.nep, &np, &coeff) )             # <<<<<<<<<<<<<<
 *         cdef object ocoeff = None
 *         try:
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNLEIGSGetRKShifts(__pyx_v_self->nep, (&__pyx_v_np), (&__pyx_v_coeff))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1735, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1736
 *         cdef PetscScalar *coeff = NULL
 *         CHKERR( NEPNLEIGSGetRKShifts(self.nep, &np, &coeff) )
 *         cdef object ocoeff = None             # <<<<<<<<<<<<<<
 *         try:
 *             ocoeff = array_s(np, coeff)
 */
  __Pyx_INCREF(Py_None);
  __pyx_v_ocoeff = Py_None;

  /* "SLEPc/NEP.pyx":1737
 *         CHKERR( NEPNLEIGSGetRKShifts(self.nep, &np, &coeff) )
 *         cdef object ocoeff = None
 *         try:             # <<<<<<<<<<<<<<
 *             ocoeff = array_s(np, coeff)
 *         finally:
 */
  /*try:*/ {

    /* "SLEPc/NEP.pyx":1738
 *         cdef object ocoeff = None
 *         try:
 *             ocoeff = array_s(np, coeff)             # <<<<<<<<<<<<<<
 *         finally:
 *             CHKERR( PetscFree(coeff) )
 */
    __pyx_t_2 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_array_s(__pyx_v_np, __pyx_v_coeff)); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1738, __pyx_L4_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF_SET(__pyx_v_ocoeff, __pyx_t_2);
    __pyx_t_2 = 0;
  }

  /* "SLEPc/NEP.pyx":1740
 *             ocoeff = array_s(np, coeff)
 *         finally:
 *             CHKERR( PetscFree(coeff) )             # <<<<<<<<<<<<<<
 *         return ocoeff
 * 
 */
  /*finally:*/ {
    /*normal exit:*/{
      __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_coeff)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1740, __pyx_L1_error)
      goto __pyx_L5;
    }
    __pyx_L4_error:;
    /*exception exit:*/{
      __Pyx_PyThreadState_declare
      __Pyx_PyThreadState_assign
      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
      if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_5);
      __Pyx_XGOTREF(__pyx_t_6);
      __Pyx_XGOTREF(__pyx_t_7);
      __Pyx_XGOTREF(__pyx_t_8);
      __Pyx_XGOTREF(__pyx_t_9);
      __Pyx_XGOTREF(__pyx_t_10);
      __pyx_t_1 = __pyx_lineno; __pyx_t_3 = __pyx_clineno; __pyx_t_4 = __pyx_filename;
      {
        __pyx_t_11 = __pyx_f_8slepc4py_5SLEPc_CHKERR(PetscFree(__pyx_v_coeff)); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(20, 1740, __pyx_L7_error)
      }
      if (PY_MAJOR_VERSION >= 3) {
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
      }
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_XGIVEREF(__pyx_t_7);
      __Pyx_ErrRestore(__pyx_t_5, __pyx_t_6, __pyx_t_7);
      __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      __pyx_lineno = __pyx_t_1; __pyx_clineno = __pyx_t_3; __pyx_filename = __pyx_t_4;
      goto __pyx_L1_error;
      __pyx_L7_error:;
      if (PY_MAJOR_VERSION >= 3) {
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_XGIVEREF(__pyx_t_9);
        __Pyx_XGIVEREF(__pyx_t_10);
        __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
      }
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
      goto __pyx_L1_error;
    }
    __pyx_L5:;
  }

  /* "SLEPc/NEP.pyx":1741
 *         finally:
 *             CHKERR( PetscFree(coeff) )
 *         return ocoeff             # <<<<<<<<<<<<<<
 * 
 *     def getNLEIGSKSPs(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_ocoeff);
  __pyx_r = __pyx_v_ocoeff;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1724
 *         CHKERR( NEPNLEIGSSetRKShifts(self.nep, na, a) )
 * 
 *     def getNLEIGSRKShifts(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the list of shifts used in the Rational Krylov method.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getNLEIGSRKShifts", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_ocoeff);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1743
 *         return ocoeff
 * 
 *     def getNLEIGSKSPs(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the array of linear solver objects associated with
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_207getNLEIGSKSPs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_206getNLEIGSKSPs[] = "NEP.getNLEIGSKSPs(self)\n\n        Retrieve the array of linear solver objects associated with\n        the NLEIGS solver.\n\n        Returns\n        -------\n        ksp: list of `KSP`\n             The linear solver objects.\n\n        Notes\n        -----\n        The number of `KSP` solvers is equal to the number of shifts provided\n        by the user, or 1 if the user did not provide shifts.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_207getNLEIGSKSPs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getNLEIGSKSPs (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getNLEIGSKSPs", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNLEIGSKSPs", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_206getNLEIGSKSPs(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_206getNLEIGSKSPs(struct PySlepcNEPObject *__pyx_v_self) {
  CYTHON_UNUSED PetscInt __pyx_v_i;
  PetscInt __pyx_v_n;
  KSP *__pyx_v_p;
  PetscInt __pyx_9genexpr15__pyx_v_i;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PetscInt __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getNLEIGSKSPs", 0);

  /* "SLEPc/NEP.pyx":1758
 *         by the user, or 1 if the user did not provide shifts.
 *         """
 *         cdef PetscInt i = 0, n = 0             # <<<<<<<<<<<<<<
 *         cdef PetscKSP *p = NULL
 *         CHKERR( NEPNLEIGSGetKSPs(self.nep, &n, &p) )
 */
  __pyx_v_i = 0;
  __pyx_v_n = 0;

  /* "SLEPc/NEP.pyx":1759
 *         """
 *         cdef PetscInt i = 0, n = 0
 *         cdef PetscKSP *p = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( NEPNLEIGSGetKSPs(self.nep, &n, &p) )
 *         return [ref_KSP(p[i]) for i from 0 <= i <n]
 */
  __pyx_v_p = NULL;

  /* "SLEPc/NEP.pyx":1760
 *         cdef PetscInt i = 0, n = 0
 *         cdef PetscKSP *p = NULL
 *         CHKERR( NEPNLEIGSGetKSPs(self.nep, &n, &p) )             # <<<<<<<<<<<<<<
 *         return [ref_KSP(p[i]) for i from 0 <= i <n]
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPNLEIGSGetKSPs(__pyx_v_self->nep, (&__pyx_v_n), (&__pyx_v_p))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1760, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1761
 *         cdef PetscKSP *p = NULL
 *         CHKERR( NEPNLEIGSGetKSPs(self.nep, &n, &p) )
 *         return [ref_KSP(p[i]) for i from 0 <= i <n]             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  { /* enter inner scope */
    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1761, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __pyx_v_n;
    for (__pyx_9genexpr15__pyx_v_i = 0; __pyx_9genexpr15__pyx_v_i < __pyx_t_3; __pyx_9genexpr15__pyx_v_i++) {
      __pyx_t_4 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_KSP((__pyx_v_p[__pyx_9genexpr15__pyx_v_i]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 1761, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_4))) __PYX_ERR(20, 1761, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  } /* exit inner scope */
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1743
 *         return ocoeff
 * 
 *     def getNLEIGSKSPs(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the array of linear solver objects associated with
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getNLEIGSKSPs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1765
 *     #
 * 
 *     def setCISSExtraction(self, extraction):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the extraction technique used in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_209setCISSExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_208setCISSExtraction[] = "NEP.setCISSExtraction(self, extraction)\n\n        Sets the extraction technique used in the CISS solver.\n\n        Parameters\n        ----------\n        extraction: `NEP.CISSExtraction` enumerate\n               The extraction technique.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_209setCISSExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_extraction = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCISSExtraction (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_extraction,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_extraction)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCISSExtraction") < 0)) __PYX_ERR(20, 1765, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_extraction = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCISSExtraction", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1765, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setCISSExtraction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_208setCISSExtraction(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_extraction);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_208setCISSExtraction(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_extraction) {
  NEPCISSExtraction __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  NEPCISSExtraction __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCISSExtraction", 0);

  /* "SLEPc/NEP.pyx":1774
 *                The extraction technique.
 *         """
 *         cdef SlepcNEPCISSExtraction val = extraction             # <<<<<<<<<<<<<<
 *         CHKERR( NEPCISSSetExtraction(self.nep, val) )
 * 
 */
  __pyx_t_1 = ((NEPCISSExtraction)__Pyx_PyInt_As_NEPCISSExtraction(__pyx_v_extraction)); if (unlikely(PyErr_Occurred())) __PYX_ERR(20, 1774, __pyx_L1_error)
  __pyx_v_val = __pyx_t_1;

  /* "SLEPc/NEP.pyx":1775
 *         """
 *         cdef SlepcNEPCISSExtraction val = extraction
 *         CHKERR( NEPCISSSetExtraction(self.nep, val) )             # <<<<<<<<<<<<<<
 * 
 *     def getCISSExtraction(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPCISSSetExtraction(__pyx_v_self->nep, __pyx_v_val)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(20, 1775, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1765
 *     #
 * 
 *     def setCISSExtraction(self, extraction):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the extraction technique used in the CISS solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setCISSExtraction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1777
 *         CHKERR( NEPCISSSetExtraction(self.nep, val) )
 * 
 *     def getCISSExtraction(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the extraction technique used in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_211getCISSExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_210getCISSExtraction[] = "NEP.getCISSExtraction(self)\n\n        Gets the extraction technique used in the CISS solver.\n\n        Returns\n        -------\n        extraction: `NEP.CISSExtraction` enumerate\n               The extraction technique.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_211getCISSExtraction(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSExtraction (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSExtraction", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSExtraction", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_210getCISSExtraction(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_210getCISSExtraction(struct PySlepcNEPObject *__pyx_v_self) {
  NEPCISSExtraction __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSExtraction", 0);

  /* "SLEPc/NEP.pyx":1786
 *                The extraction technique.
 *         """
 *         cdef SlepcNEPCISSExtraction val = NEP_CISS_EXTRACTION_RITZ             # <<<<<<<<<<<<<<
 *         CHKERR( NEPCISSGetExtraction(self.nep, &val) )
 *         return val
 */
  __pyx_v_val = NEP_CISS_EXTRACTION_RITZ;

  /* "SLEPc/NEP.pyx":1787
 *         """
 *         cdef SlepcNEPCISSExtraction val = NEP_CISS_EXTRACTION_RITZ
 *         CHKERR( NEPCISSGetExtraction(self.nep, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPCISSGetExtraction(__pyx_v_self->nep, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1787, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1788
 *         cdef SlepcNEPCISSExtraction val = NEP_CISS_EXTRACTION_RITZ
 *         CHKERR( NEPCISSGetExtraction(self.nep, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setCISSSizes(self, ip=None, bs=None, ms=None, npart=None, bsmax=None, realmats=False):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_NEPCISSExtraction(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1788, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1777
 *         CHKERR( NEPCISSSetExtraction(self.nep, val) )
 * 
 *     def getCISSExtraction(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the extraction technique used in the CISS solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getCISSExtraction", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1790
 *         return val
 * 
 *     def setCISSSizes(self, ip=None, bs=None, ms=None, npart=None, bsmax=None, realmats=False):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various size parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_213setCISSSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_212setCISSSizes[] = "NEP.setCISSSizes(self, ip=None, bs=None, ms=None, npart=None, bsmax=None, realmats=False)\n\n        Sets the values of various size parameters in the CISS solver.\n\n        Parameters\n        ----------\n        ip: int, optional\n             Number of integration points.\n        bs: int, optional\n             Block size.\n        ms: int, optional\n             Moment size.\n        npart: int, optional\n             Number of partitions when splitting the communicator.\n        bsmax: int, optional\n             Maximum block size.\n        realmats: bool, optional\n             True if A and B are real.\n\n        Notes\n        -----\n        The default number of partitions is 1. This means the internal `KSP` object\n        is shared among all processes of the `NEP` communicator. Otherwise, the\n        communicator is split into npart communicators, so that `npart` `KSP` solves\n        proceed simultaneously.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_213setCISSSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_ip = 0;
  PyObject *__pyx_v_bs = 0;
  PyObject *__pyx_v_ms = 0;
  PyObject *__pyx_v_npart = 0;
  PyObject *__pyx_v_bsmax = 0;
  PyObject *__pyx_v_realmats = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCISSSizes (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ip,&__pyx_n_s_bs,&__pyx_n_s_ms,&__pyx_n_s_npart,&__pyx_n_s_bsmax,&__pyx_n_s_realmats,0};
    PyObject* values[6] = {0,0,0,0,0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    values[3] = ((PyObject *)Py_None);
    values[4] = ((PyObject *)Py_None);
    values[5] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ip);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bs);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ms);
          if (value) { values[2] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_npart);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bsmax);
          if (value) { values[4] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_realmats);
          if (value) { values[5] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCISSSizes") < 0)) __PYX_ERR(20, 1790, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_ip = values[0];
    __pyx_v_bs = values[1];
    __pyx_v_ms = values[2];
    __pyx_v_npart = values[3];
    __pyx_v_bsmax = values[4];
    __pyx_v_realmats = values[5];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCISSSizes", 0, 0, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1790, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setCISSSizes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_212setCISSSizes(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_ip, __pyx_v_bs, __pyx_v_ms, __pyx_v_npart, __pyx_v_bsmax, __pyx_v_realmats);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_212setCISSSizes(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_ip, PyObject *__pyx_v_bs, PyObject *__pyx_v_ms, PyObject *__pyx_v_npart, PyObject *__pyx_v_bsmax, PyObject *__pyx_v_realmats) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PetscInt __pyx_v_ival4;
  PetscInt __pyx_v_ival5;
  PetscBool __pyx_v_bval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PetscInt __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCISSSizes", 0);

  /* "SLEPc/NEP.pyx":1816
 *         proceed simultaneously.
 *         """
 *         cdef PetscInt  ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival2 = PETSC_DEFAULT
 *         cdef PetscInt  ival3 = PETSC_DEFAULT
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":1817
 *         """
 *         cdef PetscInt  ival1 = PETSC_DEFAULT
 *         cdef PetscInt  ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival3 = PETSC_DEFAULT
 *         cdef PetscInt  ival4 = PETSC_DEFAULT
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":1818
 *         cdef PetscInt  ival1 = PETSC_DEFAULT
 *         cdef PetscInt  ival2 = PETSC_DEFAULT
 *         cdef PetscInt  ival3 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival4 = PETSC_DEFAULT
 *         cdef PetscInt  ival5 = PETSC_DEFAULT
 */
  __pyx_v_ival3 = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":1819
 *         cdef PetscInt  ival2 = PETSC_DEFAULT
 *         cdef PetscInt  ival3 = PETSC_DEFAULT
 *         cdef PetscInt  ival4 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival5 = PETSC_DEFAULT
 *         cdef PetscBool bval  = asBool(realmats)
 */
  __pyx_v_ival4 = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":1820
 *         cdef PetscInt  ival3 = PETSC_DEFAULT
 *         cdef PetscInt  ival4 = PETSC_DEFAULT
 *         cdef PetscInt  ival5 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscBool bval  = asBool(realmats)
 *         if ip    is not None: ival1 = asInt(ip)
 */
  __pyx_v_ival5 = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":1821
 *         cdef PetscInt  ival4 = PETSC_DEFAULT
 *         cdef PetscInt  ival5 = PETSC_DEFAULT
 *         cdef PetscBool bval  = asBool(realmats)             # <<<<<<<<<<<<<<
 *         if ip    is not None: ival1 = asInt(ip)
 *         if bs    is not None: ival2 = asInt(bs)
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asBool(__pyx_v_realmats); if (unlikely(__pyx_t_1 == ((PetscBool)((PetscBool)0)) && PyErr_Occurred())) __PYX_ERR(20, 1821, __pyx_L1_error)
  __pyx_v_bval = __pyx_t_1;

  /* "SLEPc/NEP.pyx":1822
 *         cdef PetscInt  ival5 = PETSC_DEFAULT
 *         cdef PetscBool bval  = asBool(realmats)
 *         if ip    is not None: ival1 = asInt(ip)             # <<<<<<<<<<<<<<
 *         if bs    is not None: ival2 = asInt(bs)
 *         if ms    is not None: ival3 = asInt(ms)
 */
  __pyx_t_2 = (__pyx_v_ip != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_ip); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 1822, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_4;
  }

  /* "SLEPc/NEP.pyx":1823
 *         cdef PetscBool bval  = asBool(realmats)
 *         if ip    is not None: ival1 = asInt(ip)
 *         if bs    is not None: ival2 = asInt(bs)             # <<<<<<<<<<<<<<
 *         if ms    is not None: ival3 = asInt(ms)
 *         if npart is not None: ival4 = asInt(npart)
 */
  __pyx_t_3 = (__pyx_v_bs != Py_None);
  __pyx_t_2 = (__pyx_t_3 != 0);
  if (__pyx_t_2) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_bs); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 1823, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_4;
  }

  /* "SLEPc/NEP.pyx":1824
 *         if ip    is not None: ival1 = asInt(ip)
 *         if bs    is not None: ival2 = asInt(bs)
 *         if ms    is not None: ival3 = asInt(ms)             # <<<<<<<<<<<<<<
 *         if npart is not None: ival4 = asInt(npart)
 *         if bsmax is not None: ival5 = asInt(bsmax)
 */
  __pyx_t_2 = (__pyx_v_ms != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_ms); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 1824, __pyx_L1_error)
    __pyx_v_ival3 = __pyx_t_4;
  }

  /* "SLEPc/NEP.pyx":1825
 *         if bs    is not None: ival2 = asInt(bs)
 *         if ms    is not None: ival3 = asInt(ms)
 *         if npart is not None: ival4 = asInt(npart)             # <<<<<<<<<<<<<<
 *         if bsmax is not None: ival5 = asInt(bsmax)
 *         CHKERR( NEPCISSSetSizes(self.nep, ival1, ival2, ival3, ival4, ival5, bval) )
 */
  __pyx_t_3 = (__pyx_v_npart != Py_None);
  __pyx_t_2 = (__pyx_t_3 != 0);
  if (__pyx_t_2) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_npart); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 1825, __pyx_L1_error)
    __pyx_v_ival4 = __pyx_t_4;
  }

  /* "SLEPc/NEP.pyx":1826
 *         if ms    is not None: ival3 = asInt(ms)
 *         if npart is not None: ival4 = asInt(npart)
 *         if bsmax is not None: ival5 = asInt(bsmax)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPCISSSetSizes(self.nep, ival1, ival2, ival3, ival4, ival5, bval) )
 * 
 */
  __pyx_t_2 = (__pyx_v_bsmax != Py_None);
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_bsmax); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 1826, __pyx_L1_error)
    __pyx_v_ival5 = __pyx_t_4;
  }

  /* "SLEPc/NEP.pyx":1827
 *         if npart is not None: ival4 = asInt(npart)
 *         if bsmax is not None: ival5 = asInt(bsmax)
 *         CHKERR( NEPCISSSetSizes(self.nep, ival1, ival2, ival3, ival4, ival5, bval) )             # <<<<<<<<<<<<<<
 * 
 *     def getCISSSizes(self):
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPCISSSetSizes(__pyx_v_self->nep, __pyx_v_ival1, __pyx_v_ival2, __pyx_v_ival3, __pyx_v_ival4, __pyx_v_ival5, __pyx_v_bval)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(20, 1827, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1790
 *         return val
 * 
 *     def setCISSSizes(self, ip=None, bs=None, ms=None, npart=None, bsmax=None, realmats=False):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various size parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setCISSSizes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1829
 *         CHKERR( NEPCISSSetSizes(self.nep, ival1, ival2, ival3, ival4, ival5, bval) )
 * 
 *     def getCISSSizes(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various size parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_215getCISSSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_214getCISSSizes[] = "NEP.getCISSSizes(self)\n\n        Gets the values of various size parameters in the CISS solver.\n\n        Returns\n        -------\n        ip: int\n             Number of integration points.\n        bs: int\n             Block size.\n        ms: int\n             Moment size.\n        npart: int\n             Number of partitions when splitting the communicator.\n        bsmax: int\n             Maximum block size.\n        realmats: bool\n             True if A and B are real.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_215getCISSSizes(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSSizes (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSSizes", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSSizes", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_214getCISSSizes(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_214getCISSSizes(struct PySlepcNEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PetscInt __pyx_v_ival3;
  PetscInt __pyx_v_ival4;
  PetscInt __pyx_v_ival5;
  PetscBool __pyx_v_bval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSSizes", 0);

  /* "SLEPc/NEP.pyx":1848
 *              True if A and B are real.
 *         """
 *         cdef PetscInt  ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival2 = 0
 *         cdef PetscInt  ival3 = 0
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/NEP.pyx":1849
 *         """
 *         cdef PetscInt  ival1 = 0
 *         cdef PetscInt  ival2 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival3 = 0
 *         cdef PetscInt  ival4 = 0
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/NEP.pyx":1850
 *         cdef PetscInt  ival1 = 0
 *         cdef PetscInt  ival2 = 0
 *         cdef PetscInt  ival3 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival4 = 0
 *         cdef PetscInt  ival5 = 0
 */
  __pyx_v_ival3 = 0;

  /* "SLEPc/NEP.pyx":1851
 *         cdef PetscInt  ival2 = 0
 *         cdef PetscInt  ival3 = 0
 *         cdef PetscInt  ival4 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival5 = 0
 *         cdef PetscBool bval  = PETSC_FALSE
 */
  __pyx_v_ival4 = 0;

  /* "SLEPc/NEP.pyx":1852
 *         cdef PetscInt  ival3 = 0
 *         cdef PetscInt  ival4 = 0
 *         cdef PetscInt  ival5 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscBool bval  = PETSC_FALSE
 *         CHKERR( NEPCISSGetSizes(self.nep, &ival1, &ival2, &ival3, &ival4, &ival5, &bval) )
 */
  __pyx_v_ival5 = 0;

  /* "SLEPc/NEP.pyx":1853
 *         cdef PetscInt  ival4 = 0
 *         cdef PetscInt  ival5 = 0
 *         cdef PetscBool bval  = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( NEPCISSGetSizes(self.nep, &ival1, &ival2, &ival3, &ival4, &ival5, &bval) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))
 */
  __pyx_v_bval = PETSC_FALSE;

  /* "SLEPc/NEP.pyx":1854
 *         cdef PetscInt  ival5 = 0
 *         cdef PetscBool bval  = PETSC_FALSE
 *         CHKERR( NEPCISSGetSizes(self.nep, &ival1, &ival2, &ival3, &ival4, &ival5, &bval) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPCISSGetSizes(__pyx_v_self->nep, (&__pyx_v_ival1), (&__pyx_v_ival2), (&__pyx_v_ival3), (&__pyx_v_ival4), (&__pyx_v_ival5), (&__pyx_v_bval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1854, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1855
 *         cdef PetscBool bval  = PETSC_FALSE
 *         CHKERR( NEPCISSGetSizes(self.nep, &ival1, &ival2, &ival3, &ival4, &ival5, &bval) )
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))             # <<<<<<<<<<<<<<
 * 
 *     def setCISSThreshold(self, delta=None, spur=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival3); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival4); if (unlikely(!__pyx_t_5)) __PYX_ERR(20, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival5); if (unlikely(!__pyx_t_6)) __PYX_ERR(20, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_bval); if (unlikely(!__pyx_t_7)) __PYX_ERR(20, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = PyTuple_New(6); if (unlikely(!__pyx_t_8)) __PYX_ERR(20, 1855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_7);
  PyTuple_SET_ITEM(__pyx_t_8, 5, __pyx_t_7);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_t_4 = 0;
  __pyx_t_5 = 0;
  __pyx_t_6 = 0;
  __pyx_t_7 = 0;
  __pyx_r = __pyx_t_8;
  __pyx_t_8 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1829
 *         CHKERR( NEPCISSSetSizes(self.nep, ival1, ival2, ival3, ival4, ival5, bval) )
 * 
 *     def getCISSSizes(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various size parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getCISSSizes", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1857
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))
 * 
 *     def setCISSThreshold(self, delta=None, spur=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various threshold parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_217setCISSThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_216setCISSThreshold[] = "NEP.setCISSThreshold(self, delta=None, spur=None)\n\n        Sets the values of various threshold parameters in the CISS solver.\n\n        Parameters\n        ----------\n        delta: float\n                Threshold for numerical rank.\n        spur: float\n                Spurious threshold (to discard spurious eigenpairs).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_217setCISSThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_delta = 0;
  PyObject *__pyx_v_spur = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCISSThreshold (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_delta,&__pyx_n_s_spur,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_spur);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCISSThreshold") < 0)) __PYX_ERR(20, 1857, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_delta = values[0];
    __pyx_v_spur = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCISSThreshold", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1857, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setCISSThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_216setCISSThreshold(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_delta, __pyx_v_spur);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_216setCISSThreshold(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_delta, PyObject *__pyx_v_spur) {
  PetscReal __pyx_v_rval1;
  PetscReal __pyx_v_rval2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscReal __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCISSThreshold", 0);

  /* "SLEPc/NEP.pyx":1868
 *                 Spurious threshold (to discard spurious eigenpairs).
 *         """
 *         cdef PetscReal rval1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscReal rval2 = PETSC_DEFAULT
 *         if delta is not None: rval1 = asReal(delta)
 */
  __pyx_v_rval1 = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":1869
 *         """
 *         cdef PetscReal rval1 = PETSC_DEFAULT
 *         cdef PetscReal rval2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if delta is not None: rval1 = asReal(delta)
 *         if spur  is not None: rval2 = asReal(spur)
 */
  __pyx_v_rval2 = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":1870
 *         cdef PetscReal rval1 = PETSC_DEFAULT
 *         cdef PetscReal rval2 = PETSC_DEFAULT
 *         if delta is not None: rval1 = asReal(delta)             # <<<<<<<<<<<<<<
 *         if spur  is not None: rval2 = asReal(spur)
 *         CHKERR( NEPCISSSetThreshold(self.nep, rval1, rval2) )
 */
  __pyx_t_1 = (__pyx_v_delta != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_delta); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(20, 1870, __pyx_L1_error)
    __pyx_v_rval1 = __pyx_t_3;
  }

  /* "SLEPc/NEP.pyx":1871
 *         cdef PetscReal rval2 = PETSC_DEFAULT
 *         if delta is not None: rval1 = asReal(delta)
 *         if spur  is not None: rval2 = asReal(spur)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPCISSSetThreshold(self.nep, rval1, rval2) )
 * 
 */
  __pyx_t_2 = (__pyx_v_spur != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_spur); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(20, 1871, __pyx_L1_error)
    __pyx_v_rval2 = __pyx_t_3;
  }

  /* "SLEPc/NEP.pyx":1872
 *         if delta is not None: rval1 = asReal(delta)
 *         if spur  is not None: rval2 = asReal(spur)
 *         CHKERR( NEPCISSSetThreshold(self.nep, rval1, rval2) )             # <<<<<<<<<<<<<<
 * 
 *     def getCISSThreshold(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPCISSSetThreshold(__pyx_v_self->nep, __pyx_v_rval1, __pyx_v_rval2)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(20, 1872, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1857
 *         return (toInt(ival1), toInt(ival2), toInt(ival3), toInt(ival4), toInt(ival5), toBool(bval))
 * 
 *     def setCISSThreshold(self, delta=None, spur=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various threshold parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setCISSThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1874
 *         CHKERR( NEPCISSSetThreshold(self.nep, rval1, rval2) )
 * 
 *     def getCISSThreshold(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various threshold parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_219getCISSThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_218getCISSThreshold[] = "NEP.getCISSThreshold(self)\n\n        Gets the values of various threshold parameters in the CISS solver.\n\n        Returns\n        -------\n        delta: float\n                Threshold for numerical rank.\n        spur: float\n                Spurious threshold (to discard spurious eigenpairs.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_219getCISSThreshold(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSThreshold (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSThreshold", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSThreshold", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_218getCISSThreshold(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_218getCISSThreshold(struct PySlepcNEPObject *__pyx_v_self) {
  PetscReal __pyx_v_delta;
  PetscReal __pyx_v_spur;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSThreshold", 0);

  /* "SLEPc/NEP.pyx":1885
 *                 Spurious threshold (to discard spurious eigenpairs.
 *         """
 *         cdef PetscReal delta = 0             # <<<<<<<<<<<<<<
 *         cdef PetscReal spur  = 0
 *         CHKERR( NEPCISSGetThreshold(self.nep, &delta, &spur) )
 */
  __pyx_v_delta = 0.0;

  /* "SLEPc/NEP.pyx":1886
 *         """
 *         cdef PetscReal delta = 0
 *         cdef PetscReal spur  = 0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPCISSGetThreshold(self.nep, &delta, &spur) )
 *         return (toReal(delta), toReal(spur))
 */
  __pyx_v_spur = 0.0;

  /* "SLEPc/NEP.pyx":1887
 *         cdef PetscReal delta = 0
 *         cdef PetscReal spur  = 0
 *         CHKERR( NEPCISSGetThreshold(self.nep, &delta, &spur) )             # <<<<<<<<<<<<<<
 *         return (toReal(delta), toReal(spur))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPCISSGetThreshold(__pyx_v_self->nep, (&__pyx_v_delta), (&__pyx_v_spur))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1887, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1888
 *         cdef PetscReal spur  = 0
 *         CHKERR( NEPCISSGetThreshold(self.nep, &delta, &spur) )
 *         return (toReal(delta), toReal(spur))             # <<<<<<<<<<<<<<
 * 
 *     def setCISSRefinement(self, inner=None, blsize=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_delta); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_spur); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 1888, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1874
 *         CHKERR( NEPCISSSetThreshold(self.nep, rval1, rval2) )
 * 
 *     def getCISSThreshold(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various threshold parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getCISSThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1890
 *         return (toReal(delta), toReal(spur))
 * 
 *     def setCISSRefinement(self, inner=None, blsize=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various refinement parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_221setCISSRefinement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_220setCISSRefinement[] = "NEP.setCISSRefinement(self, inner=None, blsize=None)\n\n        Sets the values of various refinement parameters in the CISS solver.\n\n        Parameters\n        ----------\n        inner: int, optional\n             Number of iterative refinement iterations (inner loop).\n        blsize: int, optional\n             Number of iterative refinement iterations (blocksize loop).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_221setCISSRefinement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_inner = 0;
  PyObject *__pyx_v_blsize = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setCISSRefinement (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inner,&__pyx_n_s_blsize,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_inner);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_blsize);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setCISSRefinement") < 0)) __PYX_ERR(20, 1890, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_inner = values[0];
    __pyx_v_blsize = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setCISSRefinement", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(20, 1890, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setCISSRefinement", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_220setCISSRefinement(((struct PySlepcNEPObject *)__pyx_v_self), __pyx_v_inner, __pyx_v_blsize);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_220setCISSRefinement(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_inner, PyObject *__pyx_v_blsize) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscInt __pyx_t_3;
  int __pyx_t_4;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setCISSRefinement", 0);

  /* "SLEPc/NEP.pyx":1901
 *              Number of iterative refinement iterations (blocksize loop).
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if inner  is not None: ival1 = asInt(inner)
 */
  __pyx_v_ival1 = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":1902
 *         """
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if inner  is not None: ival1 = asInt(inner)
 *         if blsize is not None: ival2 = asInt(blsize)
 */
  __pyx_v_ival2 = PETSC_DEFAULT;

  /* "SLEPc/NEP.pyx":1903
 *         cdef PetscInt ival1 = PETSC_DEFAULT
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if inner  is not None: ival1 = asInt(inner)             # <<<<<<<<<<<<<<
 *         if blsize is not None: ival2 = asInt(blsize)
 *         CHKERR( NEPCISSSetRefinement(self.nep, ival1, ival2) )
 */
  __pyx_t_1 = (__pyx_v_inner != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_inner); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 1903, __pyx_L1_error)
    __pyx_v_ival1 = __pyx_t_3;
  }

  /* "SLEPc/NEP.pyx":1904
 *         cdef PetscInt ival2 = PETSC_DEFAULT
 *         if inner  is not None: ival1 = asInt(inner)
 *         if blsize is not None: ival2 = asInt(blsize)             # <<<<<<<<<<<<<<
 *         CHKERR( NEPCISSSetRefinement(self.nep, ival1, ival2) )
 * 
 */
  __pyx_t_2 = (__pyx_v_blsize != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_blsize); if (unlikely(__pyx_t_3 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(20, 1904, __pyx_L1_error)
    __pyx_v_ival2 = __pyx_t_3;
  }

  /* "SLEPc/NEP.pyx":1905
 *         if inner  is not None: ival1 = asInt(inner)
 *         if blsize is not None: ival2 = asInt(blsize)
 *         CHKERR( NEPCISSSetRefinement(self.nep, ival1, ival2) )             # <<<<<<<<<<<<<<
 * 
 *     def getCISSRefinement(self):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPCISSSetRefinement(__pyx_v_self->nep, __pyx_v_ival1, __pyx_v_ival2)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(20, 1905, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1890
 *         return (toReal(delta), toReal(spur))
 * 
 *     def setCISSRefinement(self, inner=None, blsize=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the values of various refinement parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.setCISSRefinement", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1907
 *         CHKERR( NEPCISSSetRefinement(self.nep, ival1, ival2) )
 * 
 *     def getCISSRefinement(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various refinement parameters in the CISS solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_223getCISSRefinement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_222getCISSRefinement[] = "NEP.getCISSRefinement(self)\n\n        Gets the values of various refinement parameters in the CISS solver.\n\n        Returns\n        -------\n        inner: int\n             Number of iterative refinement iterations (inner loop).\n        blsize: int\n             Number of iterative refinement iterations (blocksize loop).\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_223getCISSRefinement(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSRefinement (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSRefinement", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSRefinement", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_222getCISSRefinement(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_222getCISSRefinement(struct PySlepcNEPObject *__pyx_v_self) {
  PetscInt __pyx_v_ival1;
  PetscInt __pyx_v_ival2;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSRefinement", 0);

  /* "SLEPc/NEP.pyx":1918
 *              Number of iterative refinement iterations (blocksize loop).
 *         """
 *         cdef PetscInt ival1 = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt ival2 = 0
 *         CHKERR( NEPCISSGetRefinement(self.nep, &ival1, &ival2) )
 */
  __pyx_v_ival1 = 0;

  /* "SLEPc/NEP.pyx":1919
 *         """
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0             # <<<<<<<<<<<<<<
 *         CHKERR( NEPCISSGetRefinement(self.nep, &ival1, &ival2) )
 *         return (toInt(ival1), toInt(ival2))
 */
  __pyx_v_ival2 = 0;

  /* "SLEPc/NEP.pyx":1920
 *         cdef PetscInt ival1 = 0
 *         cdef PetscInt ival2 = 0
 *         CHKERR( NEPCISSGetRefinement(self.nep, &ival1, &ival2) )             # <<<<<<<<<<<<<<
 *         return (toInt(ival1), toInt(ival2))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPCISSGetRefinement(__pyx_v_self->nep, (&__pyx_v_ival1), (&__pyx_v_ival2))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1920, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1921
 *         cdef PetscInt ival2 = 0
 *         CHKERR( NEPCISSGetRefinement(self.nep, &ival1, &ival2) )
 *         return (toInt(ival1), toInt(ival2))             # <<<<<<<<<<<<<<
 * 
 *     def getCISSKSPs(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival1); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival2); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 1921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1907
 *         CHKERR( NEPCISSSetRefinement(self.nep, ival1, ival2) )
 * 
 *     def getCISSRefinement(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the values of various refinement parameters in the CISS solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getCISSRefinement", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1923
 *         return (toInt(ival1), toInt(ival2))
 * 
 *     def getCISSKSPs(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the array of linear solver objects associated with
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_225getCISSKSPs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3NEP_224getCISSKSPs[] = "NEP.getCISSKSPs(self)\n\n        Retrieve the array of linear solver objects associated with\n        the CISS solver.\n\n        Returns\n        -------\n        ksp: list of `KSP`\n             The linear solver objects.\n\n        Notes\n        -----\n        The number of `KSP` solvers is equal to the number of integration\n        points divided by the number of partitions. This value is halved in\n        the case of real matrices with a region centered at the real axis.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_225getCISSKSPs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getCISSKSPs (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getCISSKSPs", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCISSKSPs", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_224getCISSKSPs(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_224getCISSKSPs(struct PySlepcNEPObject *__pyx_v_self) {
  CYTHON_UNUSED PetscInt __pyx_v_i;
  PetscInt __pyx_v_n;
  KSP *__pyx_v_p;
  PetscInt __pyx_9genexpr16__pyx_v_i;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PetscInt __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getCISSKSPs", 0);

  /* "SLEPc/NEP.pyx":1939
 *         the case of real matrices with a region centered at the real axis.
 *         """
 *         cdef PetscInt i = 0, n = 0             # <<<<<<<<<<<<<<
 *         cdef PetscKSP *p = NULL
 *         CHKERR( NEPCISSGetKSPs(self.nep, &n, &p) )
 */
  __pyx_v_i = 0;
  __pyx_v_n = 0;

  /* "SLEPc/NEP.pyx":1940
 *         """
 *         cdef PetscInt i = 0, n = 0
 *         cdef PetscKSP *p = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( NEPCISSGetKSPs(self.nep, &n, &p) )
 *         return [ref_KSP(p[i]) for i from 0 <= i <n]
 */
  __pyx_v_p = NULL;

  /* "SLEPc/NEP.pyx":1941
 *         cdef PetscInt i = 0, n = 0
 *         cdef PetscKSP *p = NULL
 *         CHKERR( NEPCISSGetKSPs(self.nep, &n, &p) )             # <<<<<<<<<<<<<<
 *         return [ref_KSP(p[i]) for i from 0 <= i <n]
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(NEPCISSGetKSPs(__pyx_v_self->nep, (&__pyx_v_n), (&__pyx_v_p))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(20, 1941, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":1942
 *         cdef PetscKSP *p = NULL
 *         CHKERR( NEPCISSGetKSPs(self.nep, &n, &p) )
 *         return [ref_KSP(p[i]) for i from 0 <= i <n]             # <<<<<<<<<<<<<<
 * 
 *     property problem_type:
 */
  __Pyx_XDECREF(__pyx_r);
  { /* enter inner scope */
    __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1942, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __pyx_v_n;
    for (__pyx_9genexpr16__pyx_v_i = 0; __pyx_9genexpr16__pyx_v_i < __pyx_t_3; __pyx_9genexpr16__pyx_v_i++) {
      __pyx_t_4 = ((PyObject *)__pyx_f_8slepc4py_5SLEPc_ref_KSP((__pyx_v_p[__pyx_9genexpr16__pyx_v_i]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 1942, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_4))) __PYX_ERR(20, 1942, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  } /* exit inner scope */
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1923
 *         return (toInt(ival1), toInt(ival2))
 * 
 *     def getCISSKSPs(self):             # <<<<<<<<<<<<<<
 *         """
 *         Retrieve the array of linear solver objects associated with
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.getCISSKSPs", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1945
 * 
 *     property problem_type:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getProblemType()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_12problem_type_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_12problem_type_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_12problem_type___get__(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_12problem_type___get__(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/NEP.pyx":1946
 *     property problem_type:
 *         def __get__(self):
 *             return self.getProblemType()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setProblemType(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getProblemType); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1946, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1946, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1945
 * 
 *     property problem_type:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getProblemType()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.problem_type.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1947
 *         def __get__(self):
 *             return self.getProblemType()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setProblemType(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_12problem_type_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_12problem_type_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_12problem_type_2__set__(((struct PySlepcNEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3NEP_12problem_type_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/NEP.pyx":1948
 *             return self.getProblemType()
 *         def __set__(self, value):
 *             self.setProblemType(value)             # <<<<<<<<<<<<<<
 * 
 *     property which:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setProblemType); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1948, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1948, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1947
 *         def __get__(self):
 *             return self.getProblemType()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setProblemType(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.problem_type.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1951
 * 
 *     property which:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_5which_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_5which_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_5which___get__(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_5which___get__(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/NEP.pyx":1952
 *     property which:
 *         def __get__(self):
 *             return self.getWhichEigenpairs()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setWhichEigenpairs(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getWhichEigenpairs); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1952, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1952, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1951
 * 
 *     property which:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.which.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1953
 *         def __get__(self):
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setWhichEigenpairs(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_5which_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_5which_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_5which_2__set__(((struct PySlepcNEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3NEP_5which_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/NEP.pyx":1954
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):
 *             self.setWhichEigenpairs(value)             # <<<<<<<<<<<<<<
 * 
 *     property target:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setWhichEigenpairs); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1954, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1954, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1953
 *         def __get__(self):
 *             return self.getWhichEigenpairs()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setWhichEigenpairs(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.which.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1957
 * 
 *     property target:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTarget()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_6target_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_6target_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_6target___get__(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_6target___get__(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/NEP.pyx":1958
 *     property target:
 *         def __get__(self):
 *             return self.getTarget()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTarget(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTarget); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1958, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1958, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1957
 * 
 *     property target:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTarget()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.target.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1959
 *         def __get__(self):
 *             return self.getTarget()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTarget(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_6target_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_6target_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_6target_2__set__(((struct PySlepcNEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3NEP_6target_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/NEP.pyx":1960
 *             return self.getTarget()
 *         def __set__(self, value):
 *             self.setTarget(value)             # <<<<<<<<<<<<<<
 * 
 *     property tol:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTarget); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1960, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1960, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1959
 *         def __get__(self):
 *             return self.getTarget()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTarget(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.target.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1963
 * 
 *     property tol:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_3tol_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_3tol_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_3tol___get__(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_3tol___get__(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/NEP.pyx":1964
 *     property tol:
 *         def __get__(self):
 *             return self.getTolerances()[0]             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTolerances(tol=value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTolerances); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1964, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1964, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1964, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1963
 * 
 *     property tol:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.tol.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1965
 *         def __get__(self):
 *             return self.getTolerances()[0]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(tol=value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_3tol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_3tol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_3tol_2__set__(((struct PySlepcNEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3NEP_3tol_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/NEP.pyx":1966
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 *             self.setTolerances(tol=value)             # <<<<<<<<<<<<<<
 * 
 *     property max_it:
 */
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTolerances); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1966, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1966, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_tol, __pyx_v_value) < 0) __PYX_ERR(20, 1966, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1966, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/NEP.pyx":1965
 *         def __get__(self):
 *             return self.getTolerances()[0]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(tol=value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.tol.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1969
 * 
 *     property max_it:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_6max_it_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_6max_it_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_6max_it___get__(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_6max_it___get__(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/NEP.pyx":1970
 *     property max_it:
 *         def __get__(self):
 *             return self.getTolerances()[1]             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTolerances(max_it=value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTolerances); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1970, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1970, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1970, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1969
 * 
 *     property max_it:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.max_it.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1971
 *         def __get__(self):
 *             return self.getTolerances()[1]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(max_it=value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_6max_it_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_6max_it_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_6max_it_2__set__(((struct PySlepcNEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3NEP_6max_it_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/NEP.pyx":1972
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 *             self.setTolerances(max_it=value)             # <<<<<<<<<<<<<<
 * 
 *     property track_all:
 */
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTolerances); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1972, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1972, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_it, __pyx_v_value) < 0) __PYX_ERR(20, 1972, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(20, 1972, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/NEP.pyx":1971
 *         def __get__(self):
 *             return self.getTolerances()[1]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(max_it=value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.max_it.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1975
 * 
 *     property track_all:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTrackAll()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_9track_all_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_9track_all_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_9track_all___get__(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_9track_all___get__(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/NEP.pyx":1976
 *     property track_all:
 *         def __get__(self):
 *             return self.getTrackAll()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTrackAll(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTrackAll); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1976, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1976, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1975
 * 
 *     property track_all:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTrackAll()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.track_all.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1977
 *         def __get__(self):
 *             return self.getTrackAll()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTrackAll(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_9track_all_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_9track_all_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_9track_all_2__set__(((struct PySlepcNEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3NEP_9track_all_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/NEP.pyx":1978
 *             return self.getTrackAll()
 *         def __set__(self, value):
 *             self.setTrackAll(value)             # <<<<<<<<<<<<<<
 * 
 *     property bv:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTrackAll); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1978, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1978, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1977
 *         def __get__(self):
 *             return self.getTrackAll()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTrackAll(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.track_all.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1981
 * 
 *     property bv:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getBV()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_2bv_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_2bv_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_2bv___get__(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_2bv___get__(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/NEP.pyx":1982
 *     property bv:
 *         def __get__(self):
 *             return self.getBV()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setBV(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getBV); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1982, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1982, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1981
 * 
 *     property bv:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getBV()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.bv.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1983
 *         def __get__(self):
 *             return self.getBV()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setBV(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_2bv_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_2bv_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_2bv_2__set__(((struct PySlepcNEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3NEP_2bv_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/NEP.pyx":1984
 *             return self.getBV()
 *         def __set__(self, value):
 *             self.setBV(value)             # <<<<<<<<<<<<<<
 * 
 *     property rg:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setBV); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1984, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1984, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1983
 *         def __get__(self):
 *             return self.getBV()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setBV(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.bv.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1987
 * 
 *     property rg:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getRG()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_2rg_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_2rg_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_2rg___get__(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_2rg___get__(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/NEP.pyx":1988
 *     property rg:
 *         def __get__(self):
 *             return self.getRG()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setRG(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getRG); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1988, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1988, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1987
 * 
 *     property rg:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getRG()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.rg.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1989
 *         def __get__(self):
 *             return self.getRG()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setRG(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_2rg_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_2rg_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_2rg_2__set__(((struct PySlepcNEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3NEP_2rg_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/NEP.pyx":1990
 *             return self.getRG()
 *         def __set__(self, value):
 *             self.setRG(value)             # <<<<<<<<<<<<<<
 * 
 *     property ds:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setRG); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1990, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1990, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1989
 *         def __get__(self):
 *             return self.getRG()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setRG(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.rg.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1993
 * 
 *     property ds:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getDS()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_2ds_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3NEP_2ds_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_2ds___get__(((struct PySlepcNEPObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3NEP_2ds___get__(struct PySlepcNEPObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/NEP.pyx":1994
 *     property ds:
 *         def __get__(self):
 *             return self.getDS()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setDS(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getDS); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1994, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1994, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/NEP.pyx":1993
 * 
 *     property ds:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getDS()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.ds.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/NEP.pyx":1995
 *         def __get__(self):
 *             return self.getDS()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setDS(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_2ds_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3NEP_2ds_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3NEP_2ds_2__set__(((struct PySlepcNEPObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3NEP_2ds_2__set__(struct PySlepcNEPObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/NEP.pyx":1996
 *             return self.getDS()
 *         def __set__(self, value):
 *             self.setDS(value)             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setDS); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 1996, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 1996, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/NEP.pyx":1995
 *         def __get__(self):
 *             return self.getDS()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setDS(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.NEP.ds.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":34
 *     ConvergedReason = MFNConvergedReason
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.mfn
 *         self.mfn = NULL
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3MFN_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3MFN_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN___cinit__(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3MFN___cinit__(struct PySlepcMFNObject *__pyx_v_self) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__cinit__", 0);

  /* "SLEPc/MFN.pyx":35
 * 
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.mfn             # <<<<<<<<<<<<<<
 *         self.mfn = NULL
 * 
 */
  __pyx_v_self->__pyx_base.obj = ((PetscObject *)(&__pyx_v_self->mfn));

  /* "SLEPc/MFN.pyx":36
 *     def __cinit__(self):
 *         self.obj = <PetscObject*> &self.mfn
 *         self.mfn = NULL             # <<<<<<<<<<<<<<
 * 
 *     def view(self, Viewer viewer=None):
 */
  __pyx_v_self->mfn = NULL;

  /* "SLEPc/MFN.pyx":34
 *     ConvergedReason = MFNConvergedReason
 * 
 *     def __cinit__(self):             # <<<<<<<<<<<<<<
 *         self.obj = <PetscObject*> &self.mfn
 *         self.mfn = NULL
 */

  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":38
 *         self.mfn = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the MFN data structure.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_2view[] = "MFN.view(self, Viewer viewer=None)\n\n        Prints the MFN data structure.\n\n        Parameters\n        ----------\n        viewer: Viewer, optional.\n            Visualization context; if not provided, the standard\n            output is used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_3view(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscViewerObject *__pyx_v_viewer = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("view (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_viewer,0};
    PyObject* values[1] = {0};
    values[0] = (PyObject *)((struct PyPetscViewerObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_viewer);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "view") < 0)) __PYX_ERR(21, 38, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_viewer = ((struct PyPetscViewerObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("view", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 38, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewer), __pyx_ptype_8petsc4py_5PETSc_Viewer, 1, "viewer", 0))) __PYX_ERR(21, 38, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_2view(((struct PySlepcMFNObject *)__pyx_v_self), __pyx_v_viewer);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_2view(struct PySlepcMFNObject *__pyx_v_self, struct PyPetscViewerObject *__pyx_v_viewer) {
  PetscViewer __pyx_v_vwr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("view", 0);

  /* "SLEPc/MFN.pyx":48
 *             output is used.
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)             # <<<<<<<<<<<<<<
 *         CHKERR( MFNView(self.mfn, vwr) )
 * 
 */
  __pyx_v_vwr = __pyx_f_8slepc4py_5SLEPc_def_Viewer(__pyx_v_viewer);

  /* "SLEPc/MFN.pyx":49
 *         """
 *         cdef PetscViewer vwr = def_Viewer(viewer)
 *         CHKERR( MFNView(self.mfn, vwr) )             # <<<<<<<<<<<<<<
 * 
 *     def destroy(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNView(__pyx_v_self->mfn, __pyx_v_vwr)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 49, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":38
 *         self.mfn = NULL
 * 
 *     def view(self, Viewer viewer=None):             # <<<<<<<<<<<<<<
 *         """
 *         Prints the MFN data structure.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.view", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":51
 *         CHKERR( MFNView(self.mfn, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the MFN object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_4destroy[] = "MFN.destroy(self)\n\n        Destroys the MFN object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_5destroy(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("destroy (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("destroy", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "destroy", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_4destroy(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_4destroy(struct PySlepcMFNObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("destroy", 0);

  /* "SLEPc/MFN.pyx":55
 *         Destroys the MFN object.
 *         """
 *         CHKERR( MFNDestroy(&self.mfn) )             # <<<<<<<<<<<<<<
 *         self.mfn = NULL
 *         return self
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNDestroy((&__pyx_v_self->mfn))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 55, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":56
 *         """
 *         CHKERR( MFNDestroy(&self.mfn) )
 *         self.mfn = NULL             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  __pyx_v_self->mfn = NULL;

  /* "SLEPc/MFN.pyx":57
 *         CHKERR( MFNDestroy(&self.mfn) )
 *         self.mfn = NULL
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def reset(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":51
 *         CHKERR( MFNView(self.mfn, vwr) )
 * 
 *     def destroy(self):             # <<<<<<<<<<<<<<
 *         """
 *         Destroys the MFN object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.destroy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":59
 *         return self
 * 
 *     def reset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Resets the MFN object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_7reset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_6reset[] = "MFN.reset(self)\n\n        Resets the MFN object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_7reset(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("reset (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("reset", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "reset", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_6reset(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_6reset(struct PySlepcMFNObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("reset", 0);

  /* "SLEPc/MFN.pyx":63
 *         Resets the MFN object.
 *         """
 *         CHKERR( MFNReset(self.mfn) )             # <<<<<<<<<<<<<<
 * 
 *     def create(self, comm=None):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNReset(__pyx_v_self->mfn)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 63, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":59
 *         return self
 * 
 *     def reset(self):             # <<<<<<<<<<<<<<
 *         """
 *         Resets the MFN object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.reset", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":65
 *         CHKERR( MFNReset(self.mfn) )
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the MFN object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_9create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_8create[] = "MFN.create(self, comm=None)\n\n        Creates the MFN object.\n\n        Parameters\n        ----------\n        comm: Comm, optional.\n            MPI communicator. If not provided, it defaults to all\n            processes.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_9create(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_comm = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("create (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_comm,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_comm);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create") < 0)) __PYX_ERR(21, 65, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_comm = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("create", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 65, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_8create(((struct PySlepcMFNObject *)__pyx_v_self), __pyx_v_comm);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_8create(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_comm) {
  MPI_Comm __pyx_v_ccomm;
  MFN __pyx_v_newmfn;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  MPI_Comm __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("create", 0);

  /* "SLEPc/MFN.pyx":75
 *             processes.
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())             # <<<<<<<<<<<<<<
 *         cdef SlepcMFN newmfn = NULL
 *         CHKERR( MFNCreate(ccomm, &newmfn) )
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_def_Comm(__pyx_v_comm, __pyx_f_8slepc4py_5SLEPc_SLEPC_COMM_DEFAULT()); if (unlikely(PyErr_Occurred())) __PYX_ERR(21, 75, __pyx_L1_error)
  __pyx_v_ccomm = __pyx_t_1;

  /* "SLEPc/MFN.pyx":76
 *         """
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcMFN newmfn = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( MFNCreate(ccomm, &newmfn) )
 *         SlepcCLEAR(self.obj); self.mfn = newmfn
 */
  __pyx_v_newmfn = NULL;

  /* "SLEPc/MFN.pyx":77
 *         cdef MPI_Comm ccomm = def_Comm(comm, SLEPC_COMM_DEFAULT())
 *         cdef SlepcMFN newmfn = NULL
 *         CHKERR( MFNCreate(ccomm, &newmfn) )             # <<<<<<<<<<<<<<
 *         SlepcCLEAR(self.obj); self.mfn = newmfn
 *         return self
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNCreate(__pyx_v_ccomm, (&__pyx_v_newmfn))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(21, 77, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":78
 *         cdef SlepcMFN newmfn = NULL
 *         CHKERR( MFNCreate(ccomm, &newmfn) )
 *         SlepcCLEAR(self.obj); self.mfn = newmfn             # <<<<<<<<<<<<<<
 *         return self
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_SlepcCLEAR(__pyx_v_self->__pyx_base.obj));
  __pyx_v_self->mfn = __pyx_v_newmfn;

  /* "SLEPc/MFN.pyx":79
 *         CHKERR( MFNCreate(ccomm, &newmfn) )
 *         SlepcCLEAR(self.obj); self.mfn = newmfn
 *         return self             # <<<<<<<<<<<<<<
 * 
 *     def setType(self, mfn_type):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_self));
  __pyx_r = ((PyObject *)__pyx_v_self);
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":65
 *         CHKERR( MFNReset(self.mfn) )
 * 
 *     def create(self, comm=None):             # <<<<<<<<<<<<<<
 *         """
 *         Creates the MFN object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":81
 *         return self
 * 
 *     def setType(self, mfn_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the particular solver to be used in the MFN object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_11setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_10setType[] = "MFN.setType(self, mfn_type)\n\n        Selects the particular solver to be used in the MFN object.\n\n        Parameters\n        ----------\n        mfn_type: `MFN.Type` enumerate\n            The solver to be used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_11setType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_mfn_type = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setType (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_mfn_type,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mfn_type)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setType") < 0)) __PYX_ERR(21, 81, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_mfn_type = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setType", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 81, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_10setType(((struct PySlepcMFNObject *)__pyx_v_self), __pyx_v_mfn_type);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_10setType(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_mfn_type) {
  const char* __pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setType", 0);
  __Pyx_INCREF(__pyx_v_mfn_type);

  /* "SLEPc/MFN.pyx":90
 *             The solver to be used.
 *         """
 *         cdef SlepcMFNType cval = NULL             # <<<<<<<<<<<<<<
 *         mfn_type = str2bytes(mfn_type, &cval)
 *         CHKERR( MFNSetType(self.mfn, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/MFN.pyx":91
 *         """
 *         cdef SlepcMFNType cval = NULL
 *         mfn_type = str2bytes(mfn_type, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( MFNSetType(self.mfn, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_mfn_type, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 91, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_mfn_type, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/MFN.pyx":92
 *         cdef SlepcMFNType cval = NULL
 *         mfn_type = str2bytes(mfn_type, &cval)
 *         CHKERR( MFNSetType(self.mfn, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def getType(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNSetType(__pyx_v_self->mfn, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(21, 92, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":81
 *         return self
 * 
 *     def setType(self, mfn_type):             # <<<<<<<<<<<<<<
 *         """
 *         Selects the particular solver to be used in the MFN object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_mfn_type);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":94
 *         CHKERR( MFNSetType(self.mfn, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the MFN type of this object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_13getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_12getType[] = "MFN.getType(self)\n\n        Gets the MFN type of this object.\n\n        Returns\n        -------\n        type: `MFN.Type` enumerate\n            The solver currently being used.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_13getType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getType (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getType", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getType", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_12getType(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_12getType(struct PySlepcMFNObject *__pyx_v_self) {
  const char* __pyx_v_mfn_type;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getType", 0);

  /* "SLEPc/MFN.pyx":103
 *             The solver currently being used.
 *         """
 *         cdef SlepcMFNType mfn_type = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( MFNGetType(self.mfn, &mfn_type) )
 *         return bytes2str(mfn_type)
 */
  __pyx_v_mfn_type = NULL;

  /* "SLEPc/MFN.pyx":104
 *         """
 *         cdef SlepcMFNType mfn_type = NULL
 *         CHKERR( MFNGetType(self.mfn, &mfn_type) )             # <<<<<<<<<<<<<<
 *         return bytes2str(mfn_type)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNGetType(__pyx_v_self->mfn, (&__pyx_v_mfn_type))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 104, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":105
 *         cdef SlepcMFNType mfn_type = NULL
 *         CHKERR( MFNGetType(self.mfn, &mfn_type) )
 *         return bytes2str(mfn_type)             # <<<<<<<<<<<<<<
 * 
 *     def getOptionsPrefix(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_mfn_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 105, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":94
 *         CHKERR( MFNSetType(self.mfn, cval) )
 * 
 *     def getType(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the MFN type of this object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.getType", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":107
 *         return bytes2str(mfn_type)
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all MFN options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_15getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_14getOptionsPrefix[] = "MFN.getOptionsPrefix(self)\n\n        Gets the prefix used for searching for all MFN options in the\n        database.\n\n        Returns\n        -------\n        prefix: string\n            The prefix string set for this MFN object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_15getOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOptionsPrefix (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOptionsPrefix", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOptionsPrefix", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_14getOptionsPrefix(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_14getOptionsPrefix(struct PySlepcMFNObject *__pyx_v_self) {
  const char *__pyx_v_prefix;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOptionsPrefix", 0);

  /* "SLEPc/MFN.pyx":117
 *             The prefix string set for this MFN object.
 *         """
 *         cdef const_char *prefix = NULL             # <<<<<<<<<<<<<<
 *         CHKERR( MFNGetOptionsPrefix(self.mfn, &prefix) )
 *         return bytes2str(prefix)
 */
  __pyx_v_prefix = NULL;

  /* "SLEPc/MFN.pyx":118
 *         """
 *         cdef const_char *prefix = NULL
 *         CHKERR( MFNGetOptionsPrefix(self.mfn, &prefix) )             # <<<<<<<<<<<<<<
 *         return bytes2str(prefix)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNGetOptionsPrefix(__pyx_v_self->mfn, (&__pyx_v_prefix))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 118, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":119
 *         cdef const_char *prefix = NULL
 *         CHKERR( MFNGetOptionsPrefix(self.mfn, &prefix) )
 *         return bytes2str(prefix)             # <<<<<<<<<<<<<<
 * 
 *     def setOptionsPrefix(self, prefix):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_bytes2str(__pyx_v_prefix); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":107
 *         return bytes2str(mfn_type)
 * 
 *     def getOptionsPrefix(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the prefix used for searching for all MFN options in the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.getOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":121
 *         return bytes2str(prefix)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all MFN options in the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_17setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_16setOptionsPrefix[] = "MFN.setOptionsPrefix(self, prefix)\n\n        Sets the prefix used for searching for all MFN options in the\n        database.\n\n        Parameters\n        ----------\n        prefix: string\n            The prefix string to prepend to all MFN option requests.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_17setOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOptionsPrefix") < 0)) __PYX_ERR(21, 121, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 121, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_16setOptionsPrefix(((struct PySlepcMFNObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_16setOptionsPrefix(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/MFN.pyx":131
 *             The prefix string to prepend to all MFN option requests.
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( MFNSetOptionsPrefix(self.mfn, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/MFN.pyx":132
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( MFNSetOptionsPrefix(self.mfn, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 132, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/MFN.pyx":133
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( MFNSetOptionsPrefix(self.mfn, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def appendOptionsPrefix(self, prefix):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNSetOptionsPrefix(__pyx_v_self->mfn, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(21, 133, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":121
 *         return bytes2str(prefix)
 * 
 *     def setOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the prefix used for searching for all MFN options in the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":135
 *         CHKERR( MFNSetOptionsPrefix(self.mfn, cval) )
 * 
 *     def appendOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Appends to the prefix used for searching for all MFN options
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_19appendOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_18appendOptionsPrefix[] = "MFN.appendOptionsPrefix(self, prefix)\n\n        Appends to the prefix used for searching for all MFN options\n        in the database.\n\n        Parameters\n        ----------\n        prefix: string\n            The prefix string to prepend to all MFN option requests.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_19appendOptionsPrefix(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_prefix = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("appendOptionsPrefix (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prefix,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_prefix)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "appendOptionsPrefix") < 0)) __PYX_ERR(21, 135, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_prefix = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("appendOptionsPrefix", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 135, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.appendOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_18appendOptionsPrefix(((struct PySlepcMFNObject *)__pyx_v_self), __pyx_v_prefix);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_18appendOptionsPrefix(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_prefix) {
  const char *__pyx_v_cval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("appendOptionsPrefix", 0);
  __Pyx_INCREF(__pyx_v_prefix);

  /* "SLEPc/MFN.pyx":145
 *             The prefix string to prepend to all MFN option requests.
 *         """
 *         cdef const_char *cval = NULL             # <<<<<<<<<<<<<<
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( MFNAppendOptionsPrefix(self.mfn, cval) )
 */
  __pyx_v_cval = NULL;

  /* "SLEPc/MFN.pyx":146
 *         """
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)             # <<<<<<<<<<<<<<
 *         CHKERR( MFNAppendOptionsPrefix(self.mfn, cval) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_str2bytes(__pyx_v_prefix, (&__pyx_v_cval)); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 146, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF_SET(__pyx_v_prefix, __pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/MFN.pyx":147
 *         cdef const_char *cval = NULL
 *         prefix = str2bytes(prefix, &cval)
 *         CHKERR( MFNAppendOptionsPrefix(self.mfn, cval) )             # <<<<<<<<<<<<<<
 * 
 *     def setFromOptions(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNAppendOptionsPrefix(__pyx_v_self->mfn, __pyx_v_cval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(21, 147, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":135
 *         CHKERR( MFNSetOptionsPrefix(self.mfn, cval) )
 * 
 *     def appendOptionsPrefix(self, prefix):             # <<<<<<<<<<<<<<
 *         """
 *         Appends to the prefix used for searching for all MFN options
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.appendOptionsPrefix", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_prefix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":149
 *         CHKERR( MFNAppendOptionsPrefix(self.mfn, cval) )
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets MFN options from the options database. This routine must
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_21setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_20setFromOptions[] = "MFN.setFromOptions(self)\n\n        Sets MFN options from the options database. This routine must\n        be called before `setUp()` if the user is to be allowed to set\n        the solver type.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_21setFromOptions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFromOptions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setFromOptions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setFromOptions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_20setFromOptions(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_20setFromOptions(struct PySlepcMFNObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFromOptions", 0);

  /* "SLEPc/MFN.pyx":155
 *         the solver type.
 *         """
 *         CHKERR( MFNSetFromOptions(self.mfn) )             # <<<<<<<<<<<<<<
 * 
 *     def getTolerances(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNSetFromOptions(__pyx_v_self->mfn)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 155, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":149
 *         CHKERR( MFNAppendOptionsPrefix(self.mfn, cval) )
 * 
 *     def setFromOptions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets MFN options from the options database. This routine must
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setFromOptions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":157
 *         CHKERR( MFNSetFromOptions(self.mfn) )
 * 
 *     def getTolerances(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance and maximum iteration count used by the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_23getTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_22getTolerances[] = "MFN.getTolerances(self)\n\n        Gets the tolerance and maximum iteration count used by the\n        default MFN convergence tests.\n\n        Returns\n        -------\n        tol: float\n            The convergence tolerance.\n        max_it: int\n            The maximum number of iterations\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_23getTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getTolerances (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getTolerances", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTolerances", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_22getTolerances(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_22getTolerances(struct PySlepcMFNObject *__pyx_v_self) {
  PetscReal __pyx_v_rval;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getTolerances", 0);

  /* "SLEPc/MFN.pyx":169
 *             The maximum number of iterations
 *         """
 *         cdef PetscReal rval = 0             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = 0
 *         CHKERR( MFNGetTolerances(self.mfn, &rval, &ival) )
 */
  __pyx_v_rval = 0.0;

  /* "SLEPc/MFN.pyx":170
 *         """
 *         cdef PetscReal rval = 0
 *         cdef PetscInt  ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( MFNGetTolerances(self.mfn, &rval, &ival) )
 *         return (toReal(rval), toInt(ival))
 */
  __pyx_v_ival = 0;

  /* "SLEPc/MFN.pyx":171
 *         cdef PetscReal rval = 0
 *         cdef PetscInt  ival = 0
 *         CHKERR( MFNGetTolerances(self.mfn, &rval, &ival) )             # <<<<<<<<<<<<<<
 *         return (toReal(rval), toInt(ival))
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNGetTolerances(__pyx_v_self->mfn, (&__pyx_v_rval), (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 171, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":172
 *         cdef PetscInt  ival = 0
 *         CHKERR( MFNGetTolerances(self.mfn, &rval, &ival) )
 *         return (toReal(rval), toInt(ival))             # <<<<<<<<<<<<<<
 * 
 *     def setTolerances(self, tol=None, max_it=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toReal(__pyx_v_rval); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
  __pyx_t_2 = 0;
  __pyx_t_3 = 0;
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":157
 *         CHKERR( MFNSetFromOptions(self.mfn) )
 * 
 *     def getTolerances(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the tolerance and maximum iteration count used by the
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.getTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":174
 *         return (toReal(rval), toInt(ival))
 * 
 *     def setTolerances(self, tol=None, max_it=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance and maximum iteration count used by the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_25setTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_24setTolerances[] = "MFN.setTolerances(self, tol=None, max_it=None)\n\n        Sets the tolerance and maximum iteration count used by the\n        default MFN convergence tests.\n\n        Parameters\n        ----------\n        tol: float, optional\n            The convergence tolerance.\n        max_it: int, optional\n            The maximum number of iterations\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_25setTolerances(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_tol = 0;
  PyObject *__pyx_v_max_it = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setTolerances (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_tol,&__pyx_n_s_max_it,0};
    PyObject* values[2] = {0,0};
    values[0] = ((PyObject *)Py_None);
    values[1] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tol);
          if (value) { values[0] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_it);
          if (value) { values[1] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setTolerances") < 0)) __PYX_ERR(21, 174, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_tol = values[0];
    __pyx_v_max_it = values[1];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setTolerances", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 174, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_24setTolerances(((struct PySlepcMFNObject *)__pyx_v_self), __pyx_v_tol, __pyx_v_max_it);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_24setTolerances(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_tol, PyObject *__pyx_v_max_it) {
  PetscReal __pyx_v_rval;
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PetscReal __pyx_t_3;
  PetscInt __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setTolerances", 0);

  /* "SLEPc/MFN.pyx":186
 *             The maximum number of iterations
 *         """
 *         cdef PetscReal rval = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol    is not None: rval = asReal(tol)
 */
  __pyx_v_rval = PETSC_DEFAULT;

  /* "SLEPc/MFN.pyx":187
 *         """
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 *         if tol    is not None: rval = asReal(tol)
 *         if max_it is not None: ival = asInt(max_it)
 */
  __pyx_v_ival = PETSC_DEFAULT;

  /* "SLEPc/MFN.pyx":188
 *         cdef PetscReal rval = PETSC_DEFAULT
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol    is not None: rval = asReal(tol)             # <<<<<<<<<<<<<<
 *         if max_it is not None: ival = asInt(max_it)
 *         CHKERR( MFNSetTolerances(self.mfn, rval, ival) )
 */
  __pyx_t_1 = (__pyx_v_tol != Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __pyx_t_3 = __pyx_f_8slepc4py_5SLEPc_asReal(__pyx_v_tol); if (unlikely(__pyx_t_3 == ((PetscReal)-1.0) && PyErr_Occurred())) __PYX_ERR(21, 188, __pyx_L1_error)
    __pyx_v_rval = __pyx_t_3;
  }

  /* "SLEPc/MFN.pyx":189
 *         cdef PetscInt  ival = PETSC_DEFAULT
 *         if tol    is not None: rval = asReal(tol)
 *         if max_it is not None: ival = asInt(max_it)             # <<<<<<<<<<<<<<
 *         CHKERR( MFNSetTolerances(self.mfn, rval, ival) )
 * 
 */
  __pyx_t_2 = (__pyx_v_max_it != Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_max_it); if (unlikely(__pyx_t_4 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(21, 189, __pyx_L1_error)
    __pyx_v_ival = __pyx_t_4;
  }

  /* "SLEPc/MFN.pyx":190
 *         if tol    is not None: rval = asReal(tol)
 *         if max_it is not None: ival = asInt(max_it)
 *         CHKERR( MFNSetTolerances(self.mfn, rval, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getDimensions(self):
 */
  __pyx_t_5 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNSetTolerances(__pyx_v_self->mfn, __pyx_v_rval, __pyx_v_ival)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(21, 190, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":174
 *         return (toReal(rval), toInt(ival))
 * 
 *     def setTolerances(self, tol=None, max_it=None):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the tolerance and maximum iteration count used by the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setTolerances", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":192
 *         CHKERR( MFNSetTolerances(self.mfn, rval, ival) )
 * 
 *     def getDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the dimension of the subspace used by the solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_27getDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_26getDimensions[] = "MFN.getDimensions(self)\n\n        Gets the dimension of the subspace used by the solver.\n\n        Returns\n        -------\n        ncv: int\n            Maximum dimension of the subspace to be used by the solver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_27getDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getDimensions (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getDimensions", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDimensions", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_26getDimensions(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_26getDimensions(struct PySlepcMFNObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getDimensions", 0);

  /* "SLEPc/MFN.pyx":201
 *             Maximum dimension of the subspace to be used by the solver.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( MFNGetDimensions(self.mfn, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/MFN.pyx":202
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( MFNGetDimensions(self.mfn, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNGetDimensions(__pyx_v_self->mfn, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 202, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":203
 *         cdef PetscInt ival = 0
 *         CHKERR( MFNGetDimensions(self.mfn, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def setDimensions(self, ncv):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 203, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":192
 *         CHKERR( MFNSetTolerances(self.mfn, rval, ival) )
 * 
 *     def getDimensions(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the dimension of the subspace used by the solver.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.getDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":205
 *         return toInt(ival)
 * 
 *     def setDimensions(self, ncv):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the dimension of the subspace to be used by the solver.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_29setDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_28setDimensions[] = "MFN.setDimensions(self, ncv)\n\n        Sets the dimension of the subspace to be used by the solver.\n\n        Parameters\n        ----------\n        ncv: int\n            Maximum dimension of the subspace to be used by the\n            solver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_29setDimensions(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_ncv = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setDimensions (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ncv,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ncv)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setDimensions") < 0)) __PYX_ERR(21, 205, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_ncv = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setDimensions", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 205, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_28setDimensions(((struct PySlepcMFNObject *)__pyx_v_self), __pyx_v_ncv);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_28setDimensions(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_ncv) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscInt __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setDimensions", 0);

  /* "SLEPc/MFN.pyx":215
 *             solver.
 *         """
 *         cdef PetscInt ival = asInt(ncv)             # <<<<<<<<<<<<<<
 *         CHKERR( MFNSetDimensions(self.mfn, ival) )
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_asInt(__pyx_v_ncv); if (unlikely(__pyx_t_1 == ((PetscInt)-1L) && PyErr_Occurred())) __PYX_ERR(21, 215, __pyx_L1_error)
  __pyx_v_ival = __pyx_t_1;

  /* "SLEPc/MFN.pyx":216
 *         """
 *         cdef PetscInt ival = asInt(ncv)
 *         CHKERR( MFNSetDimensions(self.mfn, ival) )             # <<<<<<<<<<<<<<
 * 
 *     def getFN(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNSetDimensions(__pyx_v_self->mfn, __pyx_v_ival)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(21, 216, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":205
 *         return toInt(ival)
 * 
 *     def setDimensions(self, ncv):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the dimension of the subspace to be used by the solver.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setDimensions", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":218
 *         CHKERR( MFNSetDimensions(self.mfn, ival) )
 * 
 *     def getFN(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the math function object associated to the MFN object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_31getFN(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_30getFN[] = "MFN.getFN(self)\n\n        Obtain the math function object associated to the MFN object.\n\n        Returns\n        -------\n        fn: FN\n            The math function context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_31getFN(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getFN (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getFN", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getFN", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_30getFN(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_30getFN(struct PySlepcMFNObject *__pyx_v_self) {
  struct PySlepcFNObject *__pyx_v_fn = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getFN", 0);

  /* "SLEPc/MFN.pyx":227
 *             The math function context.
 *         """
 *         cdef FN fn = FN()             # <<<<<<<<<<<<<<
 *         CHKERR( MFNGetFN(self.mfn, &fn.fn) )
 *         PetscINCREF(fn.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_FN)); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 227, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_fn = ((struct PySlepcFNObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/MFN.pyx":228
 *         """
 *         cdef FN fn = FN()
 *         CHKERR( MFNGetFN(self.mfn, &fn.fn) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(fn.obj)
 *         return fn
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNGetFN(__pyx_v_self->mfn, (&__pyx_v_fn->fn))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(21, 228, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":229
 *         cdef FN fn = FN()
 *         CHKERR( MFNGetFN(self.mfn, &fn.fn) )
 *         PetscINCREF(fn.obj)             # <<<<<<<<<<<<<<
 *         return fn
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_fn->__pyx_base.obj));

  /* "SLEPc/MFN.pyx":230
 *         CHKERR( MFNGetFN(self.mfn, &fn.fn) )
 *         PetscINCREF(fn.obj)
 *         return fn             # <<<<<<<<<<<<<<
 * 
 *     def setFN(self, FN fn):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_fn));
  __pyx_r = ((PyObject *)__pyx_v_fn);
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":218
 *         CHKERR( MFNSetDimensions(self.mfn, ival) )
 * 
 *     def getFN(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the math function object associated to the MFN object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.getFN", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_fn);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":232
 *         return fn
 * 
 *     def setFN(self, FN fn):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a math function object to the MFN object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_33setFN(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_32setFN[] = "MFN.setFN(self, FN fn)\n\n        Associates a math function object to the MFN object.\n\n        Parameters\n        ----------\n        fn: FN\n            The math function context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_33setFN(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcFNObject *__pyx_v_fn = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setFN (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fn,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fn)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setFN") < 0)) __PYX_ERR(21, 232, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_fn = ((struct PySlepcFNObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setFN", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 232, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setFN", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_fn), __pyx_ptype_8slepc4py_5SLEPc_FN, 0, "fn", 0))) __PYX_ERR(21, 232, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_32setFN(((struct PySlepcMFNObject *)__pyx_v_self), __pyx_v_fn);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_32setFN(struct PySlepcMFNObject *__pyx_v_self, struct PySlepcFNObject *__pyx_v_fn) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setFN", 0);

  /* "SLEPc/MFN.pyx":241
 *             The math function context.
 *         """
 *         CHKERR( MFNSetFN(self.mfn, fn.fn) )             # <<<<<<<<<<<<<<
 * 
 *     def getBV(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNSetFN(__pyx_v_self->mfn, __pyx_v_fn->fn)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 241, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":232
 *         return fn
 * 
 *     def setFN(self, FN fn):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a math function object to the MFN object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setFN", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":243
 *         CHKERR( MFNSetFN(self.mfn, fn.fn) )
 * 
 *     def getBV(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the basis vector object associated to the MFN object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_35getBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_34getBV[] = "MFN.getBV(self)\n\n        Obtain the basis vector object associated to the MFN object.\n\n        Returns\n        -------\n        bv: BV\n            The basis vectors context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_35getBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getBV (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getBV", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBV", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_34getBV(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_34getBV(struct PySlepcMFNObject *__pyx_v_self) {
  struct PySlepcBVObject *__pyx_v_bv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getBV", 0);

  /* "SLEPc/MFN.pyx":252
 *             The basis vectors context.
 *         """
 *         cdef BV bv = BV()             # <<<<<<<<<<<<<<
 *         CHKERR( MFNGetBV(self.mfn, &bv.bv) )
 *         PetscINCREF(bv.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV)); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 252, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_bv = ((struct PySlepcBVObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/MFN.pyx":253
 *         """
 *         cdef BV bv = BV()
 *         CHKERR( MFNGetBV(self.mfn, &bv.bv) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(bv.obj)
 *         return bv
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNGetBV(__pyx_v_self->mfn, (&__pyx_v_bv->bv))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(21, 253, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":254
 *         cdef BV bv = BV()
 *         CHKERR( MFNGetBV(self.mfn, &bv.bv) )
 *         PetscINCREF(bv.obj)             # <<<<<<<<<<<<<<
 *         return bv
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_bv->__pyx_base.obj));

  /* "SLEPc/MFN.pyx":255
 *         CHKERR( MFNGetBV(self.mfn, &bv.bv) )
 *         PetscINCREF(bv.obj)
 *         return bv             # <<<<<<<<<<<<<<
 * 
 *     def setBV(self, BV bv):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_bv));
  __pyx_r = ((PyObject *)__pyx_v_bv);
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":243
 *         CHKERR( MFNSetFN(self.mfn, fn.fn) )
 * 
 *     def getBV(self):             # <<<<<<<<<<<<<<
 *         """
 *         Obtain the basis vector object associated to the MFN object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.getBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_bv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":257
 *         return bv
 * 
 *     def setBV(self, BV bv):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a basis vector object to the MFN object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_37setBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_36setBV[] = "MFN.setBV(self, BV bv)\n\n        Associates a basis vector object to the MFN object.\n\n        Parameters\n        ----------\n        bv: BV\n            The basis vectors context.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_37setBV(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PySlepcBVObject *__pyx_v_bv = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setBV (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bv,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bv)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setBV") < 0)) __PYX_ERR(21, 257, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_bv = ((struct PySlepcBVObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setBV", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 257, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_bv), __pyx_ptype_8slepc4py_5SLEPc_BV, 0, "bv", 0))) __PYX_ERR(21, 257, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_36setBV(((struct PySlepcMFNObject *)__pyx_v_self), __pyx_v_bv);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_36setBV(struct PySlepcMFNObject *__pyx_v_self, struct PySlepcBVObject *__pyx_v_bv) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setBV", 0);

  /* "SLEPc/MFN.pyx":266
 *             The basis vectors context.
 *         """
 *         CHKERR( MFNSetBV(self.mfn, bv.bv) )             # <<<<<<<<<<<<<<
 * 
 *     def getOperator(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNSetBV(__pyx_v_self->mfn, __pyx_v_bv->bv)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 266, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":257
 *         return bv
 * 
 *     def setBV(self, BV bv):             # <<<<<<<<<<<<<<
 *         """
 *         Associates a basis vector object to the MFN object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":268
 *         CHKERR( MFNSetBV(self.mfn, bv.bv) )
 * 
 *     def getOperator(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the matrix associated with the MFN object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_39getOperator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_38getOperator[] = "MFN.getOperator(self)\n\n        Gets the matrix associated with the MFN object.\n\n        Returns\n        -------\n        A: Mat\n            The matrix for which the matrix function is to be computed.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_39getOperator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getOperator (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getOperator", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOperator", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_38getOperator(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_38getOperator(struct PySlepcMFNObject *__pyx_v_self) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getOperator", 0);

  /* "SLEPc/MFN.pyx":277
 *             The matrix for which the matrix function is to be computed.
 *         """
 *         cdef Mat A = Mat()             # <<<<<<<<<<<<<<
 *         CHKERR( MFNGetOperator(self.mfn, &A.mat) )
 *         PetscINCREF(A.obj)
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8petsc4py_5PETSc_Mat)); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 277, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_A = ((struct PyPetscMatObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/MFN.pyx":278
 *         """
 *         cdef Mat A = Mat()
 *         CHKERR( MFNGetOperator(self.mfn, &A.mat) )             # <<<<<<<<<<<<<<
 *         PetscINCREF(A.obj)
 *         return A
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNGetOperator(__pyx_v_self->mfn, (&__pyx_v_A->mat))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(21, 278, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":279
 *         cdef Mat A = Mat()
 *         CHKERR( MFNGetOperator(self.mfn, &A.mat) )
 *         PetscINCREF(A.obj)             # <<<<<<<<<<<<<<
 *         return A
 * 
 */
  (void)(__pyx_f_8slepc4py_5SLEPc_PetscINCREF(__pyx_v_A->__pyx_base.obj));

  /* "SLEPc/MFN.pyx":280
 *         CHKERR( MFNGetOperator(self.mfn, &A.mat) )
 *         PetscINCREF(A.obj)
 *         return A             # <<<<<<<<<<<<<<
 * 
 *     def setOperator(self, Mat A):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_A));
  __pyx_r = ((PyObject *)__pyx_v_A);
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":268
 *         CHKERR( MFNSetBV(self.mfn, bv.bv) )
 * 
 *     def getOperator(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the matrix associated with the MFN object.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.getOperator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_A);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":282
 *         return A
 * 
 *     def setOperator(self, Mat A):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the matrix associated with the MFN object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_41setOperator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_40setOperator[] = "MFN.setOperator(self, Mat A)\n\n        Sets the matrix associated with the MFN object.\n\n        Parameters\n        ----------\n        A: Mat\n            The problem matrix.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_41setOperator(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscMatObject *__pyx_v_A = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setOperator (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_A,0};
    PyObject* values[1] = {0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_A)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setOperator") < 0)) __PYX_ERR(21, 282, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
    }
    __pyx_v_A = ((struct PyPetscMatObject *)values[0]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setOperator", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 282, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setOperator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_A), __pyx_ptype_8petsc4py_5PETSc_Mat, 0, "A", 0))) __PYX_ERR(21, 282, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_40setOperator(((struct PySlepcMFNObject *)__pyx_v_self), __pyx_v_A);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_40setOperator(struct PySlepcMFNObject *__pyx_v_self, struct PyPetscMatObject *__pyx_v_A) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setOperator", 0);

  /* "SLEPc/MFN.pyx":291
 *             The problem matrix.
 *         """
 *         CHKERR( MFNSetOperator(self.mfn, A.mat) )             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNSetOperator(__pyx_v_self->mfn, __pyx_v_A->mat)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 291, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":282
 *         return A
 * 
 *     def setOperator(self, Mat A):             # <<<<<<<<<<<<<<
 *         """
 *         Sets the matrix associated with the MFN object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setOperator", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":295
 *     #
 * 
 *     def setMonitor(self, monitor, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Appends a monitor function to the list of monitors.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_43setMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_42setMonitor[] = "MFN.setMonitor(self, monitor, args=None, kargs=None)\n\n        Appends a monitor function to the list of monitors.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_43setMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_monitor = 0;
  PyObject *__pyx_v_args = 0;
  PyObject *__pyx_v_kargs = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setMonitor (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_monitor,&__pyx_n_s_args,&__pyx_n_s_kargs,0};
    PyObject* values[3] = {0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_monitor)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args);
          if (value) { values[1] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kargs);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setMonitor") < 0)) __PYX_ERR(21, 295, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_monitor = values[0];
    __pyx_v_args = values[1];
    __pyx_v_kargs = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setMonitor", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 295, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_42setMonitor(((struct PySlepcMFNObject *)__pyx_v_self), __pyx_v_monitor, __pyx_v_args, __pyx_v_kargs);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_42setMonitor(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_monitor, PyObject *__pyx_v_args, PyObject *__pyx_v_kargs) {
  PyObject *__pyx_v_monitorlist = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  int __pyx_t_5;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setMonitor", 0);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);

  /* "SLEPc/MFN.pyx":299
 *         Appends a monitor function to the list of monitors.
 *         """
 *         if monitor is None: return             # <<<<<<<<<<<<<<
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:
 */
  __pyx_t_1 = (__pyx_v_monitor == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;
  }

  /* "SLEPc/MFN.pyx":300
 *         """
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 *         if monitorlist is None:
 *             monitorlist = []
 */
  __pyx_t_3 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_MFN *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__")); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 300, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_monitorlist = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "SLEPc/MFN.pyx":301
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:             # <<<<<<<<<<<<<<
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 */
  __pyx_t_2 = (__pyx_v_monitorlist == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {

    /* "SLEPc/MFN.pyx":302
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:
 *             monitorlist = []             # <<<<<<<<<<<<<<
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( MFNMonitorSet(self.mfn, MFN_Monitor, NULL, NULL) )
 */
    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 302, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_monitorlist, __pyx_t_3);
    __pyx_t_3 = 0;

    /* "SLEPc/MFN.pyx":303
 *         if monitorlist is None:
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)             # <<<<<<<<<<<<<<
 *             CHKERR( MFNMonitorSet(self.mfn, MFN_Monitor, NULL, NULL) )
 *         if args is None: args = ()
 */
    __pyx_t_3 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_MFN *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__"), __pyx_v_monitorlist); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 303, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

    /* "SLEPc/MFN.pyx":304
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( MFNMonitorSet(self.mfn, MFN_Monitor, NULL, NULL) )             # <<<<<<<<<<<<<<
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}
 */
    __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNMonitorSet(__pyx_v_self->mfn, __pyx_f_8slepc4py_5SLEPc_MFN_Monitor, NULL, NULL)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(21, 304, __pyx_L1_error)

    /* "SLEPc/MFN.pyx":301
 *         if monitor is None: return
 *         cdef object monitorlist = self.get_attr('__monitor__')
 *         if monitorlist is None:             # <<<<<<<<<<<<<<
 *             monitorlist = []
 *             self.set_attr('__monitor__', monitorlist)
 */
  }

  /* "SLEPc/MFN.pyx":305
 *             self.set_attr('__monitor__', monitorlist)
 *             CHKERR( MFNMonitorSet(self.mfn, MFN_Monitor, NULL, NULL) )
 *         if args is None: args = ()             # <<<<<<<<<<<<<<
 *         if kargs is None: kargs = {}
 *         monitorlist.append((monitor, args, kargs))
 */
  __pyx_t_1 = (__pyx_v_args == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {
    __Pyx_INCREF(__pyx_empty_tuple);
    __Pyx_DECREF_SET(__pyx_v_args, __pyx_empty_tuple);
  }

  /* "SLEPc/MFN.pyx":306
 *             CHKERR( MFNMonitorSet(self.mfn, MFN_Monitor, NULL, NULL) )
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}             # <<<<<<<<<<<<<<
 *         monitorlist.append((monitor, args, kargs))
 * 
 */
  __pyx_t_2 = (__pyx_v_kargs == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {
    __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 306, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_kargs, __pyx_t_3);
    __pyx_t_3 = 0;
  }

  /* "SLEPc/MFN.pyx":307
 *         if args is None: args = ()
 *         if kargs is None: kargs = {}
 *         monitorlist.append((monitor, args, kargs))             # <<<<<<<<<<<<<<
 * 
 *     def getMonitor(self):
 */
  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 307, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_monitor);
  __Pyx_GIVEREF(__pyx_v_monitor);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_monitor);
  __Pyx_INCREF(__pyx_v_args);
  __Pyx_GIVEREF(__pyx_v_args);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_args);
  __Pyx_INCREF(__pyx_v_kargs);
  __Pyx_GIVEREF(__pyx_v_kargs);
  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_kargs);
  __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_monitorlist, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(21, 307, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/MFN.pyx":295
 *     #
 * 
 *     def setMonitor(self, monitor, args=None, kargs=None):             # <<<<<<<<<<<<<<
 *         """
 *         Appends a monitor function to the list of monitors.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_monitorlist);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_kargs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":309
 *         monitorlist.append((monitor, args, kargs))
 * 
 *     def getMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the list of monitor functions.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_45getMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_44getMonitor[] = "MFN.getMonitor(self)\n\n        Gets the list of monitor functions.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_45getMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getMonitor (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getMonitor", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getMonitor", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_44getMonitor(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_44getMonitor(struct PySlepcMFNObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getMonitor", 0);

  /* "SLEPc/MFN.pyx":313
 *         Gets the list of monitor functions.
 *         """
 *         return self.get_attr('__monitor__')             # <<<<<<<<<<<<<<
 * 
 *     def cancelMonitor(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_MFN *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__")); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 313, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":309
 *         monitorlist.append((monitor, args, kargs))
 * 
 *     def getMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the list of monitor functions.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.getMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":315
 *         return self.get_attr('__monitor__')
 * 
 *     def cancelMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Clears all monitors for an `MFN` object.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_47cancelMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_46cancelMonitor[] = "MFN.cancelMonitor(self)\n\n        Clears all monitors for an `MFN` object.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_47cancelMonitor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("cancelMonitor (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("cancelMonitor", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "cancelMonitor", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_46cancelMonitor(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_46cancelMonitor(struct PySlepcMFNObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("cancelMonitor", 0);

  /* "SLEPc/MFN.pyx":319
 *         Clears all monitors for an `MFN` object.
 *         """
 *         CHKERR( MFNMonitorCancel(self.mfn) )             # <<<<<<<<<<<<<<
 *         self.set_attr('__monitor__', None)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNMonitorCancel(__pyx_v_self->mfn)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 319, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":320
 *         """
 *         CHKERR( MFNMonitorCancel(self.mfn) )
 *         self.set_attr('__monitor__', None)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __pyx_t_2 = ((struct __pyx_vtabstruct_8slepc4py_5SLEPc_MFN *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.set_attr(((struct PyPetscObjectObject *)__pyx_v_self), ((char *)"__monitor__"), Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 320, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/MFN.pyx":315
 *         return self.get_attr('__monitor__')
 * 
 *     def cancelMonitor(self):             # <<<<<<<<<<<<<<
 *         """
 *         Clears all monitors for an `MFN` object.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.cancelMonitor", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":324
 *     #
 * 
 *     def setUp(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets up all the internal data structures necessary for the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_49setUp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_48setUp[] = "MFN.setUp(self)\n\n        Sets up all the internal data structures necessary for the\n        execution of the eigensolver.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_49setUp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setUp (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("setUp", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setUp", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_48setUp(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_48setUp(struct PySlepcMFNObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setUp", 0);

  /* "SLEPc/MFN.pyx":329
 *         execution of the eigensolver.
 *         """
 *         CHKERR( MFNSetUp(self.mfn) )             # <<<<<<<<<<<<<<
 * 
 *     def solve(self, Vec b, Vec x):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNSetUp(__pyx_v_self->mfn)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 329, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":324
 *     #
 * 
 *     def setUp(self):             # <<<<<<<<<<<<<<
 *         """
 *         Sets up all the internal data structures necessary for the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setUp", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":331
 *         CHKERR( MFNSetUp(self.mfn) )
 * 
 *     def solve(self, Vec b, Vec x):             # <<<<<<<<<<<<<<
 *         """
 *         Solves the matrix function problem. Given a vector b, the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_51solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_50solve[] = "MFN.solve(self, Vec b, Vec x)\n\n        Solves the matrix function problem. Given a vector b, the\n        vector x = f(A)*b is returned.\n\n        Parameters\n        ----------\n        b: Vec\n            The right hand side vector.\n        x: Vec\n            The solution.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_51solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscVecObject *__pyx_v_b = 0;
  struct PyPetscVecObject *__pyx_v_x = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("solve (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_b,&__pyx_n_s_x,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_b)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("solve", 1, 2, 2, 1); __PYX_ERR(21, 331, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "solve") < 0)) __PYX_ERR(21, 331, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_b = ((struct PyPetscVecObject *)values[0]);
    __pyx_v_x = ((struct PyPetscVecObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("solve", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 331, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.solve", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_b), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "b", 0))) __PYX_ERR(21, 331, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_x), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "x", 0))) __PYX_ERR(21, 331, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_50solve(((struct PySlepcMFNObject *)__pyx_v_self), __pyx_v_b, __pyx_v_x);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_50solve(struct PySlepcMFNObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_b, struct PyPetscVecObject *__pyx_v_x) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("solve", 0);

  /* "SLEPc/MFN.pyx":343
 *             The solution.
 *         """
 *         CHKERR( MFNSolve(self.mfn, b.vec, x.vec) )             # <<<<<<<<<<<<<<
 * 
 *     def solveTranspose(self, Vec b, Vec x):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNSolve(__pyx_v_self->mfn, __pyx_v_b->vec, __pyx_v_x->vec)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 343, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":331
 *         CHKERR( MFNSetUp(self.mfn) )
 * 
 *     def solve(self, Vec b, Vec x):             # <<<<<<<<<<<<<<
 *         """
 *         Solves the matrix function problem. Given a vector b, the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.solve", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":345
 *         CHKERR( MFNSolve(self.mfn, b.vec, x.vec) )
 * 
 *     def solveTranspose(self, Vec b, Vec x):             # <<<<<<<<<<<<<<
 *         """
 *         Solves the transpose matrix function problem. Given a vector b, the
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_53solveTranspose(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_52solveTranspose[] = "MFN.solveTranspose(self, Vec b, Vec x)\n\n        Solves the transpose matrix function problem. Given a vector b, the\n        vector x = f(A^T)*b is returned.\n\n        Parameters\n        ----------\n        b: Vec\n            The right hand side vector.\n        x: Vec\n            The solution.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_53solveTranspose(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  struct PyPetscVecObject *__pyx_v_b = 0;
  struct PyPetscVecObject *__pyx_v_x = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("solveTranspose (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_b,&__pyx_n_s_x,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_b)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("solveTranspose", 1, 2, 2, 1); __PYX_ERR(21, 345, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "solveTranspose") < 0)) __PYX_ERR(21, 345, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_b = ((struct PyPetscVecObject *)values[0]);
    __pyx_v_x = ((struct PyPetscVecObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("solveTranspose", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 345, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.solveTranspose", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_b), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "b", 0))) __PYX_ERR(21, 345, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_x), __pyx_ptype_8petsc4py_5PETSc_Vec, 0, "x", 0))) __PYX_ERR(21, 345, __pyx_L1_error)
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_52solveTranspose(((struct PySlepcMFNObject *)__pyx_v_self), __pyx_v_b, __pyx_v_x);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_52solveTranspose(struct PySlepcMFNObject *__pyx_v_self, struct PyPetscVecObject *__pyx_v_b, struct PyPetscVecObject *__pyx_v_x) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("solveTranspose", 0);

  /* "SLEPc/MFN.pyx":357
 *             The solution.
 *         """
 *         CHKERR( MFNSolveTranspose(self.mfn, b.vec, x.vec) )             # <<<<<<<<<<<<<<
 * 
 *     def getIterationNumber(self):
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNSolveTranspose(__pyx_v_self->mfn, __pyx_v_b->vec, __pyx_v_x->vec)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 357, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":345
 *         CHKERR( MFNSolve(self.mfn, b.vec, x.vec) )
 * 
 *     def solveTranspose(self, Vec b, Vec x):             # <<<<<<<<<<<<<<
 *         """
 *         Solves the transpose matrix function problem. Given a vector b, the
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.solveTranspose", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":359
 *         CHKERR( MFNSolveTranspose(self.mfn, b.vec, x.vec) )
 * 
 *     def getIterationNumber(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the current iteration number. If the call to `solve()` is
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_55getIterationNumber(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_54getIterationNumber[] = "MFN.getIterationNumber(self)\n\n        Gets the current iteration number. If the call to `solve()` is\n        complete, then it returns the number of iterations carried out\n        by the solution method.\n\n        Returns\n        -------\n        its: int\n             Iteration number.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_55getIterationNumber(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getIterationNumber (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getIterationNumber", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getIterationNumber", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_54getIterationNumber(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_54getIterationNumber(struct PySlepcMFNObject *__pyx_v_self) {
  PetscInt __pyx_v_ival;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getIterationNumber", 0);

  /* "SLEPc/MFN.pyx":370
 *              Iteration number.
 *         """
 *         cdef PetscInt ival = 0             # <<<<<<<<<<<<<<
 *         CHKERR( MFNGetIterationNumber(self.mfn, &ival) )
 *         return toInt(ival)
 */
  __pyx_v_ival = 0;

  /* "SLEPc/MFN.pyx":371
 *         """
 *         cdef PetscInt ival = 0
 *         CHKERR( MFNGetIterationNumber(self.mfn, &ival) )             # <<<<<<<<<<<<<<
 *         return toInt(ival)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNGetIterationNumber(__pyx_v_self->mfn, (&__pyx_v_ival))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 371, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":372
 *         cdef PetscInt ival = 0
 *         CHKERR( MFNGetIterationNumber(self.mfn, &ival) )
 *         return toInt(ival)             # <<<<<<<<<<<<<<
 * 
 *     def getConvergedReason(self):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toInt(__pyx_v_ival); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 372, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":359
 *         CHKERR( MFNSolveTranspose(self.mfn, b.vec, x.vec) )
 * 
 *     def getIterationNumber(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the current iteration number. If the call to `solve()` is
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.getIterationNumber", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":374
 *         return toInt(ival)
 * 
 *     def getConvergedReason(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the reason why the `solve()` iteration was stopped.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_57getConvergedReason(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_56getConvergedReason[] = "MFN.getConvergedReason(self)\n\n        Gets the reason why the `solve()` iteration was stopped.\n\n        Returns\n        -------\n        reason: `MFN.ConvergedReason` enumerate\n            Negative value indicates diverged, positive value\n            converged.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_57getConvergedReason(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getConvergedReason (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getConvergedReason", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConvergedReason", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_56getConvergedReason(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_56getConvergedReason(struct PySlepcMFNObject *__pyx_v_self) {
  MFNConvergedReason __pyx_v_val;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getConvergedReason", 0);

  /* "SLEPc/MFN.pyx":384
 *             converged.
 *         """
 *         cdef SlepcMFNConvergedReason val = MFN_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *         CHKERR( MFNGetConvergedReason(self.mfn, &val) )
 *         return val
 */
  __pyx_v_val = MFN_CONVERGED_ITERATING;

  /* "SLEPc/MFN.pyx":385
 *         """
 *         cdef SlepcMFNConvergedReason val = MFN_CONVERGED_ITERATING
 *         CHKERR( MFNGetConvergedReason(self.mfn, &val) )             # <<<<<<<<<<<<<<
 *         return val
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNGetConvergedReason(__pyx_v_self->mfn, (&__pyx_v_val))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 385, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":386
 *         cdef SlepcMFNConvergedReason val = MFN_CONVERGED_ITERATING
 *         CHKERR( MFNGetConvergedReason(self.mfn, &val) )
 *         return val             # <<<<<<<<<<<<<<
 * 
 *     def setErrorIfNotConverged(self, flg=True):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyInt_From_MFNConvergedReason(__pyx_v_val); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 386, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":374
 *         return toInt(ival)
 * 
 *     def getConvergedReason(self):             # <<<<<<<<<<<<<<
 *         """
 *         Gets the reason why the `solve()` iteration was stopped.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.getConvergedReason", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":388
 *         return val
 * 
 *     def setErrorIfNotConverged(self, flg=True):             # <<<<<<<<<<<<<<
 *         """
 *         Causes `solve()` to generate an error if the solver has not converged.
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_59setErrorIfNotConverged(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_58setErrorIfNotConverged[] = "MFN.setErrorIfNotConverged(self, flg=True)\n\n        Causes `solve()` to generate an error if the solver has not converged.\n\n        Parameters\n        ----------\n        flg: bool\n            True indicates you want the error generated.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_59setErrorIfNotConverged(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_flg = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("setErrorIfNotConverged (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flg,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_True);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flg);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setErrorIfNotConverged") < 0)) __PYX_ERR(21, 388, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_flg = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("setErrorIfNotConverged", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 388, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setErrorIfNotConverged", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_58setErrorIfNotConverged(((struct PySlepcMFNObject *)__pyx_v_self), __pyx_v_flg);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_58setErrorIfNotConverged(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_flg) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PetscBool __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setErrorIfNotConverged", 0);

  /* "SLEPc/MFN.pyx":397
 *             True indicates you want the error generated.
 *         """
 *         cdef PetscBool tval = flg             # <<<<<<<<<<<<<<
 *         CHKERR( MFNSetErrorIfNotConverged(self.mfn, tval) )
 * 
 */
  __pyx_t_1 = ((PetscBool)__Pyx_PyInt_As_PetscBool(__pyx_v_flg)); if (unlikely(PyErr_Occurred())) __PYX_ERR(21, 397, __pyx_L1_error)
  __pyx_v_tval = __pyx_t_1;

  /* "SLEPc/MFN.pyx":398
 *         """
 *         cdef PetscBool tval = flg
 *         CHKERR( MFNSetErrorIfNotConverged(self.mfn, tval) )             # <<<<<<<<<<<<<<
 * 
 *     def getErrorIfNotConverged(self):
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNSetErrorIfNotConverged(__pyx_v_self->mfn, __pyx_v_tval)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(21, 398, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":388
 *         return val
 * 
 *     def setErrorIfNotConverged(self, flg=True):             # <<<<<<<<<<<<<<
 *         """
 *         Causes `solve()` to generate an error if the solver has not converged.
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.setErrorIfNotConverged", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":400
 *         CHKERR( MFNSetErrorIfNotConverged(self.mfn, tval) )
 * 
 *     def getErrorIfNotConverged(self):             # <<<<<<<<<<<<<<
 *         """
 *         Return a flag indicating whether `solve()` will generate an
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_61getErrorIfNotConverged(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_3MFN_60getErrorIfNotConverged[] = "MFN.getErrorIfNotConverged(self)\n\n        Return a flag indicating whether `solve()` will generate an\n        error if the solver does not converge.\n\n        Returns\n        -------\n        flg: bool\n            True indicates you want the error generated.\n        ";
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_61getErrorIfNotConverged(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("getErrorIfNotConverged (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("getErrorIfNotConverged", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getErrorIfNotConverged", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_60getErrorIfNotConverged(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_60getErrorIfNotConverged(struct PySlepcMFNObject *__pyx_v_self) {
  PetscBool __pyx_v_tval;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("getErrorIfNotConverged", 0);

  /* "SLEPc/MFN.pyx":410
 *             True indicates you want the error generated.
 *         """
 *         cdef PetscBool tval = PETSC_FALSE             # <<<<<<<<<<<<<<
 *         CHKERR( MFNGetErrorIfNotConverged(self.mfn, &tval) )
 *         return toBool(tval)
 */
  __pyx_v_tval = PETSC_FALSE;

  /* "SLEPc/MFN.pyx":411
 *         """
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( MFNGetErrorIfNotConverged(self.mfn, &tval) )             # <<<<<<<<<<<<<<
 *         return toBool(tval)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(MFNGetErrorIfNotConverged(__pyx_v_self->mfn, (&__pyx_v_tval))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(21, 411, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":412
 *         cdef PetscBool tval = PETSC_FALSE
 *         CHKERR( MFNGetErrorIfNotConverged(self.mfn, &tval) )
 *         return toBool(tval)             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_toBool(__pyx_v_tval); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 412, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":400
 *         CHKERR( MFNSetErrorIfNotConverged(self.mfn, tval) )
 * 
 *     def getErrorIfNotConverged(self):             # <<<<<<<<<<<<<<
 *         """
 *         Return a flag indicating whether `solve()` will generate an
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.getErrorIfNotConverged", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":417
 * 
 *     property tol:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_3tol_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_3tol_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_3tol___get__(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_3tol___get__(struct PySlepcMFNObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/MFN.pyx":418
 *     property tol:
 *         def __get__(self):
 *             return self.getTolerances()[0]             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTolerances(tol=value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTolerances); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 418, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 418, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 418, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":417
 * 
 *     property tol:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.tol.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":419
 *         def __get__(self):
 *             return self.getTolerances()[0]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(tol=value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3MFN_3tol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3MFN_3tol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_3tol_2__set__(((struct PySlepcMFNObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3MFN_3tol_2__set__(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/MFN.pyx":420
 *             return self.getTolerances()[0]
 *         def __set__(self, value):
 *             self.setTolerances(tol=value)             # <<<<<<<<<<<<<<
 * 
 *     property max_it:
 */
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTolerances); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 420, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 420, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_tol, __pyx_v_value) < 0) __PYX_ERR(21, 420, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 420, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/MFN.pyx":419
 *         def __get__(self):
 *             return self.getTolerances()[0]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(tol=value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.tol.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":423
 * 
 *     property max_it:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_6max_it_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_6max_it_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_6max_it___get__(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_6max_it___get__(struct PySlepcMFNObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/MFN.pyx":424
 *     property max_it:
 *         def __get__(self):
 *             return self.getTolerances()[1]             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setTolerances(max_it=value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTolerances); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 424, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 424, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 424, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_r = __pyx_t_2;
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":423
 * 
 *     property max_it:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.max_it.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":425
 *         def __get__(self):
 *             return self.getTolerances()[1]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(max_it=value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3MFN_6max_it_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3MFN_6max_it_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_6max_it_2__set__(((struct PySlepcMFNObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3MFN_6max_it_2__set__(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/MFN.pyx":426
 *             return self.getTolerances()[1]
 *         def __set__(self, value):
 *             self.setTolerances(max_it=value)             # <<<<<<<<<<<<<<
 * 
 *     property fn:
 */
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setTolerances); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 426, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 426, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_it, __pyx_v_value) < 0) __PYX_ERR(21, 426, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 426, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "SLEPc/MFN.pyx":425
 *         def __get__(self):
 *             return self.getTolerances()[1]
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setTolerances(max_it=value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.max_it.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":429
 * 
 *     property fn:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getFN()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_2fn_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_2fn_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_2fn___get__(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_2fn___get__(struct PySlepcMFNObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/MFN.pyx":430
 *     property fn:
 *         def __get__(self):
 *             return self.getFN()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setBV(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getFN); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 430, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 430, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":429
 * 
 *     property fn:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getFN()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.fn.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":431
 *         def __get__(self):
 *             return self.getFN()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setBV(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3MFN_2fn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3MFN_2fn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_2fn_2__set__(((struct PySlepcMFNObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3MFN_2fn_2__set__(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/MFN.pyx":432
 *             return self.getFN()
 *         def __set__(self, value):
 *             self.setBV(value)             # <<<<<<<<<<<<<<
 * 
 *     property bv:
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setBV); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 432, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 432, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/MFN.pyx":431
 *         def __get__(self):
 *             return self.getFN()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setBV(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.fn.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":435
 * 
 *     property bv:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getFN()
 *         def __set__(self, value):
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_2bv_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3MFN_2bv_1__get__(PyObject *__pyx_v_self) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_2bv___get__(((struct PySlepcMFNObject *)__pyx_v_self));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_3MFN_2bv___get__(struct PySlepcMFNObject *__pyx_v_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__get__", 0);

  /* "SLEPc/MFN.pyx":436
 *     property bv:
 *         def __get__(self):
 *             return self.getFN()             # <<<<<<<<<<<<<<
 *         def __set__(self, value):
 *             self.setBV(value)
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getFN); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 436, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 436, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "SLEPc/MFN.pyx":435
 * 
 *     property bv:
 *         def __get__(self):             # <<<<<<<<<<<<<<
 *             return self.getFN()
 *         def __set__(self, value):
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.bv.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/MFN.pyx":437
 *         def __get__(self):
 *             return self.getFN()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setBV(value)
 * 
 */

/* Python wrapper */
static int __pyx_pw_8slepc4py_5SLEPc_3MFN_2bv_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_8slepc4py_5SLEPc_3MFN_2bv_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_3MFN_2bv_2__set__(((struct PySlepcMFNObject *)__pyx_v_self), ((PyObject *)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_8slepc4py_5SLEPc_3MFN_2bv_2__set__(struct PySlepcMFNObject *__pyx_v_self, PyObject *__pyx_v_value) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__set__", 0);

  /* "SLEPc/MFN.pyx":438
 *             return self.getFN()
 *         def __set__(self, value):
 *             self.setBV(value)             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setBV); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 438, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 438, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/MFN.pyx":437
 *         def __get__(self):
 *             return self.getFN()
 *         def __set__(self, value):             # <<<<<<<<<<<<<<
 *             self.setBV(value)
 * 
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("slepc4py.SLEPc.MFN.bv.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * cdef inline int setref(void *d, void *s) except -1:             # <<<<<<<<<<<<<<
 *     cdef PetscObject *dest  = <PetscObject*> d
 *     cdef PetscObject source = <PetscObject>  s
 */

static CYTHON_INLINE int __pyx_f_8slepc4py_5SLEPc_setref(void *__pyx_v_d, void *__pyx_v_s) {
  PetscObject *__pyx_v_dest;
  PetscObject __pyx_v_source;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("setref", 0);

  /* "SLEPc/CAPI.pyx":4
 * 
 * cdef inline int setref(void *d, void *s) except -1:
 *     cdef PetscObject *dest  = <PetscObject*> d             # <<<<<<<<<<<<<<
 *     cdef PetscObject source = <PetscObject>  s
 *     CHKERR( PetscINCREF(&source) )
 */
  __pyx_v_dest = ((PetscObject *)__pyx_v_d);

  /* "SLEPc/CAPI.pyx":5
 * cdef inline int setref(void *d, void *s) except -1:
 *     cdef PetscObject *dest  = <PetscObject*> d
 *     cdef PetscObject source = <PetscObject>  s             # <<<<<<<<<<<<<<
 *     CHKERR( PetscINCREF(&source) )
 *     dest[0] = source
 */
  __pyx_v_source = ((PetscObject)__pyx_v_s);

  /* "SLEPc/CAPI.pyx":6
 *     cdef PetscObject *dest  = <PetscObject*> d
 *     cdef PetscObject source = <PetscObject>  s
 *     CHKERR( PetscINCREF(&source) )             # <<<<<<<<<<<<<<
 *     dest[0] = source
 *     return 0
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(__pyx_f_8slepc4py_5SLEPc_PetscINCREF((&__pyx_v_source))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(22, 6, __pyx_L1_error)

  /* "SLEPc/CAPI.pyx":7
 *     cdef PetscObject source = <PetscObject>  s
 *     CHKERR( PetscINCREF(&source) )
 *     dest[0] = source             # <<<<<<<<<<<<<<
 *     return 0
 * 
 */
  (__pyx_v_dest[0]) = __pyx_v_source;

  /* "SLEPc/CAPI.pyx":8
 *     CHKERR( PetscINCREF(&source) )
 *     dest[0] = source
 *     return 0             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = 0;
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * cdef inline int setref(void *d, void *s) except -1:             # <<<<<<<<<<<<<<
 *     cdef PetscObject *dest  = <PetscObject*> d
 *     cdef PetscObject source = <PetscObject>  s
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.setref", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":14
 * # -- ST --
 * 
 * cdef api object PySlepcST_New(SlepcST arg):             # <<<<<<<<<<<<<<
 *     cdef ST retv = ST()
 *     setref(&retv.st, arg)
 */

static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcST_New(ST __pyx_v_arg) {
  struct PySlepcSTObject *__pyx_v_retv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcST_New", 0);

  /* "SLEPc/CAPI.pyx":15
 * 
 * cdef api object PySlepcST_New(SlepcST arg):
 *     cdef ST retv = ST()             # <<<<<<<<<<<<<<
 *     setref(&retv.st, arg)
 *     return retv
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_ST)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_retv = ((struct PySlepcSTObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":16
 * cdef api object PySlepcST_New(SlepcST arg):
 *     cdef ST retv = ST()
 *     setref(&retv.st, arg)             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_setref((&__pyx_v_retv->st), __pyx_v_arg); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(22, 16, __pyx_L1_error)

  /* "SLEPc/CAPI.pyx":17
 *     cdef ST retv = ST()
 *     setref(&retv.st, arg)
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * cdef api SlepcST PySlepcST_Get(object arg) except ? NULL:
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_retv));
  __pyx_r = ((PyObject *)__pyx_v_retv);
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":14
 * # -- ST --
 * 
 * cdef api object PySlepcST_New(SlepcST arg):             # <<<<<<<<<<<<<<
 *     cdef ST retv = ST()
 *     setref(&retv.st, arg)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcST_New", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_retv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":19
 *     return retv
 * 
 * cdef api SlepcST PySlepcST_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcST retv = NULL
 *     cdef ST ob = <ST?> arg
 */

static ST __pyx_f_8slepc4py_5SLEPc_PySlepcST_Get(PyObject *__pyx_v_arg) {
  ST __pyx_v_retv;
  struct PySlepcSTObject *__pyx_v_ob = 0;
  ST __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  ST __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcST_Get", 0);

  /* "SLEPc/CAPI.pyx":20
 * 
 * cdef api SlepcST PySlepcST_Get(object arg) except ? NULL:
 *     cdef SlepcST retv = NULL             # <<<<<<<<<<<<<<
 *     cdef ST ob = <ST?> arg
 *     retv = ob.st
 */
  __pyx_v_retv = NULL;

  /* "SLEPc/CAPI.pyx":21
 * cdef api SlepcST PySlepcST_Get(object arg) except ? NULL:
 *     cdef SlepcST retv = NULL
 *     cdef ST ob = <ST?> arg             # <<<<<<<<<<<<<<
 *     retv = ob.st
 *     return retv
 */
  if (!(likely(__Pyx_TypeTest(__pyx_v_arg, __pyx_ptype_8slepc4py_5SLEPc_ST)))) __PYX_ERR(22, 21, __pyx_L1_error)
  __pyx_t_1 = __pyx_v_arg;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_ob = ((struct PySlepcSTObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":22
 *     cdef SlepcST retv = NULL
 *     cdef ST ob = <ST?> arg
 *     retv = ob.st             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_v_ob->st;
  __pyx_v_retv = __pyx_t_2;

  /* "SLEPc/CAPI.pyx":23
 *     cdef ST ob = <ST?> arg
 *     retv = ob.st
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = __pyx_v_retv;
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":19
 *     return retv
 * 
 * cdef api SlepcST PySlepcST_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcST retv = NULL
 *     cdef ST ob = <ST?> arg
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcST_Get", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":29
 * # -- BV --
 * 
 * cdef api object PySlepcBV_New(SlepcBV arg):             # <<<<<<<<<<<<<<
 *     cdef BV retv = BV()
 *     setref(&retv.bv, arg)
 */

static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcBV_New(BV __pyx_v_arg) {
  struct PySlepcBVObject *__pyx_v_retv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcBV_New", 0);

  /* "SLEPc/CAPI.pyx":30
 * 
 * cdef api object PySlepcBV_New(SlepcBV arg):
 *     cdef BV retv = BV()             # <<<<<<<<<<<<<<
 *     setref(&retv.bv, arg)
 *     return retv
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 30, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_retv = ((struct PySlepcBVObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":31
 * cdef api object PySlepcBV_New(SlepcBV arg):
 *     cdef BV retv = BV()
 *     setref(&retv.bv, arg)             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_setref((&__pyx_v_retv->bv), __pyx_v_arg); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(22, 31, __pyx_L1_error)

  /* "SLEPc/CAPI.pyx":32
 *     cdef BV retv = BV()
 *     setref(&retv.bv, arg)
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * cdef api SlepcBV PySlepcBV_Get(object arg) except ? NULL:
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_retv));
  __pyx_r = ((PyObject *)__pyx_v_retv);
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":29
 * # -- BV --
 * 
 * cdef api object PySlepcBV_New(SlepcBV arg):             # <<<<<<<<<<<<<<
 *     cdef BV retv = BV()
 *     setref(&retv.bv, arg)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcBV_New", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_retv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":34
 *     return retv
 * 
 * cdef api SlepcBV PySlepcBV_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcBV retv = NULL
 *     cdef BV ob = <BV?> arg
 */

static BV __pyx_f_8slepc4py_5SLEPc_PySlepcBV_Get(PyObject *__pyx_v_arg) {
  BV __pyx_v_retv;
  struct PySlepcBVObject *__pyx_v_ob = 0;
  BV __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  BV __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcBV_Get", 0);

  /* "SLEPc/CAPI.pyx":35
 * 
 * cdef api SlepcBV PySlepcBV_Get(object arg) except ? NULL:
 *     cdef SlepcBV retv = NULL             # <<<<<<<<<<<<<<
 *     cdef BV ob = <BV?> arg
 *     retv = ob.bv
 */
  __pyx_v_retv = NULL;

  /* "SLEPc/CAPI.pyx":36
 * cdef api SlepcBV PySlepcBV_Get(object arg) except ? NULL:
 *     cdef SlepcBV retv = NULL
 *     cdef BV ob = <BV?> arg             # <<<<<<<<<<<<<<
 *     retv = ob.bv
 *     return retv
 */
  if (!(likely(__Pyx_TypeTest(__pyx_v_arg, __pyx_ptype_8slepc4py_5SLEPc_BV)))) __PYX_ERR(22, 36, __pyx_L1_error)
  __pyx_t_1 = __pyx_v_arg;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_ob = ((struct PySlepcBVObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":37
 *     cdef SlepcBV retv = NULL
 *     cdef BV ob = <BV?> arg
 *     retv = ob.bv             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_v_ob->bv;
  __pyx_v_retv = __pyx_t_2;

  /* "SLEPc/CAPI.pyx":38
 *     cdef BV ob = <BV?> arg
 *     retv = ob.bv
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = __pyx_v_retv;
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":34
 *     return retv
 * 
 * cdef api SlepcBV PySlepcBV_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcBV retv = NULL
 *     cdef BV ob = <BV?> arg
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcBV_Get", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":44
 * # -- DS --
 * 
 * cdef api object PySlepcDS_New(SlepcDS arg):             # <<<<<<<<<<<<<<
 *     cdef DS retv = DS()
 *     setref(&retv.ds, arg)
 */

static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcDS_New(DS __pyx_v_arg) {
  struct PySlepcDSObject *__pyx_v_retv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcDS_New", 0);

  /* "SLEPc/CAPI.pyx":45
 * 
 * cdef api object PySlepcDS_New(SlepcDS arg):
 *     cdef DS retv = DS()             # <<<<<<<<<<<<<<
 *     setref(&retv.ds, arg)
 *     return retv
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_DS)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 45, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_retv = ((struct PySlepcDSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":46
 * cdef api object PySlepcDS_New(SlepcDS arg):
 *     cdef DS retv = DS()
 *     setref(&retv.ds, arg)             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_setref((&__pyx_v_retv->ds), __pyx_v_arg); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(22, 46, __pyx_L1_error)

  /* "SLEPc/CAPI.pyx":47
 *     cdef DS retv = DS()
 *     setref(&retv.ds, arg)
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * cdef api SlepcDS PySlepcDS_Get(object arg) except ? NULL:
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_retv));
  __pyx_r = ((PyObject *)__pyx_v_retv);
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":44
 * # -- DS --
 * 
 * cdef api object PySlepcDS_New(SlepcDS arg):             # <<<<<<<<<<<<<<
 *     cdef DS retv = DS()
 *     setref(&retv.ds, arg)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcDS_New", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_retv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":49
 *     return retv
 * 
 * cdef api SlepcDS PySlepcDS_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcDS retv = NULL
 *     cdef DS ob = <DS?> arg
 */

static DS __pyx_f_8slepc4py_5SLEPc_PySlepcDS_Get(PyObject *__pyx_v_arg) {
  DS __pyx_v_retv;
  struct PySlepcDSObject *__pyx_v_ob = 0;
  DS __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  DS __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcDS_Get", 0);

  /* "SLEPc/CAPI.pyx":50
 * 
 * cdef api SlepcDS PySlepcDS_Get(object arg) except ? NULL:
 *     cdef SlepcDS retv = NULL             # <<<<<<<<<<<<<<
 *     cdef DS ob = <DS?> arg
 *     retv = ob.ds
 */
  __pyx_v_retv = NULL;

  /* "SLEPc/CAPI.pyx":51
 * cdef api SlepcDS PySlepcDS_Get(object arg) except ? NULL:
 *     cdef SlepcDS retv = NULL
 *     cdef DS ob = <DS?> arg             # <<<<<<<<<<<<<<
 *     retv = ob.ds
 *     return retv
 */
  if (!(likely(__Pyx_TypeTest(__pyx_v_arg, __pyx_ptype_8slepc4py_5SLEPc_DS)))) __PYX_ERR(22, 51, __pyx_L1_error)
  __pyx_t_1 = __pyx_v_arg;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_ob = ((struct PySlepcDSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":52
 *     cdef SlepcDS retv = NULL
 *     cdef DS ob = <DS?> arg
 *     retv = ob.ds             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_v_ob->ds;
  __pyx_v_retv = __pyx_t_2;

  /* "SLEPc/CAPI.pyx":53
 *     cdef DS ob = <DS?> arg
 *     retv = ob.ds
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = __pyx_v_retv;
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":49
 *     return retv
 * 
 * cdef api SlepcDS PySlepcDS_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcDS retv = NULL
 *     cdef DS ob = <DS?> arg
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcDS_Get", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":59
 * # -- FN --
 * 
 * cdef api object PySlepcFN_New(SlepcFN arg):             # <<<<<<<<<<<<<<
 *     cdef FN retv = FN()
 *     setref(&retv.fn, arg)
 */

static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcFN_New(FN __pyx_v_arg) {
  struct PySlepcFNObject *__pyx_v_retv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcFN_New", 0);

  /* "SLEPc/CAPI.pyx":60
 * 
 * cdef api object PySlepcFN_New(SlepcFN arg):
 *     cdef FN retv = FN()             # <<<<<<<<<<<<<<
 *     setref(&retv.fn, arg)
 *     return retv
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_FN)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 60, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_retv = ((struct PySlepcFNObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":61
 * cdef api object PySlepcFN_New(SlepcFN arg):
 *     cdef FN retv = FN()
 *     setref(&retv.fn, arg)             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_setref((&__pyx_v_retv->fn), __pyx_v_arg); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(22, 61, __pyx_L1_error)

  /* "SLEPc/CAPI.pyx":62
 *     cdef FN retv = FN()
 *     setref(&retv.fn, arg)
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * cdef api SlepcFN PySlepcFN_Get(object arg) except ? NULL:
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_retv));
  __pyx_r = ((PyObject *)__pyx_v_retv);
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":59
 * # -- FN --
 * 
 * cdef api object PySlepcFN_New(SlepcFN arg):             # <<<<<<<<<<<<<<
 *     cdef FN retv = FN()
 *     setref(&retv.fn, arg)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcFN_New", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_retv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":64
 *     return retv
 * 
 * cdef api SlepcFN PySlepcFN_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcFN retv = NULL
 *     cdef FN ob = <FN?> arg
 */

static FN __pyx_f_8slepc4py_5SLEPc_PySlepcFN_Get(PyObject *__pyx_v_arg) {
  FN __pyx_v_retv;
  struct PySlepcFNObject *__pyx_v_ob = 0;
  FN __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  FN __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcFN_Get", 0);

  /* "SLEPc/CAPI.pyx":65
 * 
 * cdef api SlepcFN PySlepcFN_Get(object arg) except ? NULL:
 *     cdef SlepcFN retv = NULL             # <<<<<<<<<<<<<<
 *     cdef FN ob = <FN?> arg
 *     retv = ob.fn
 */
  __pyx_v_retv = NULL;

  /* "SLEPc/CAPI.pyx":66
 * cdef api SlepcFN PySlepcFN_Get(object arg) except ? NULL:
 *     cdef SlepcFN retv = NULL
 *     cdef FN ob = <FN?> arg             # <<<<<<<<<<<<<<
 *     retv = ob.fn
 *     return retv
 */
  if (!(likely(__Pyx_TypeTest(__pyx_v_arg, __pyx_ptype_8slepc4py_5SLEPc_FN)))) __PYX_ERR(22, 66, __pyx_L1_error)
  __pyx_t_1 = __pyx_v_arg;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_ob = ((struct PySlepcFNObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":67
 *     cdef SlepcFN retv = NULL
 *     cdef FN ob = <FN?> arg
 *     retv = ob.fn             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_v_ob->fn;
  __pyx_v_retv = __pyx_t_2;

  /* "SLEPc/CAPI.pyx":68
 *     cdef FN ob = <FN?> arg
 *     retv = ob.fn
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = __pyx_v_retv;
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":64
 *     return retv
 * 
 * cdef api SlepcFN PySlepcFN_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcFN retv = NULL
 *     cdef FN ob = <FN?> arg
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcFN_Get", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":74
 * # -- RG --
 * 
 * cdef api object PySlepcRG_New(SlepcRG arg):             # <<<<<<<<<<<<<<
 *     cdef RG retv = RG()
 *     setref(&retv.rg, arg)
 */

static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcRG_New(RG __pyx_v_arg) {
  struct PySlepcRGObject *__pyx_v_retv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcRG_New", 0);

  /* "SLEPc/CAPI.pyx":75
 * 
 * cdef api object PySlepcRG_New(SlepcRG arg):
 *     cdef RG retv = RG()             # <<<<<<<<<<<<<<
 *     setref(&retv.rg, arg)
 *     return retv
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_RG)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 75, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_retv = ((struct PySlepcRGObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":76
 * cdef api object PySlepcRG_New(SlepcRG arg):
 *     cdef RG retv = RG()
 *     setref(&retv.rg, arg)             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_setref((&__pyx_v_retv->rg), __pyx_v_arg); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(22, 76, __pyx_L1_error)

  /* "SLEPc/CAPI.pyx":77
 *     cdef RG retv = RG()
 *     setref(&retv.rg, arg)
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * cdef api SlepcRG PySlepcRG_Get(object arg) except ? NULL:
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_retv));
  __pyx_r = ((PyObject *)__pyx_v_retv);
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":74
 * # -- RG --
 * 
 * cdef api object PySlepcRG_New(SlepcRG arg):             # <<<<<<<<<<<<<<
 *     cdef RG retv = RG()
 *     setref(&retv.rg, arg)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcRG_New", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_retv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":79
 *     return retv
 * 
 * cdef api SlepcRG PySlepcRG_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcRG retv = NULL
 *     cdef RG ob = <RG?> arg
 */

static RG __pyx_f_8slepc4py_5SLEPc_PySlepcRG_Get(PyObject *__pyx_v_arg) {
  RG __pyx_v_retv;
  struct PySlepcRGObject *__pyx_v_ob = 0;
  RG __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  RG __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcRG_Get", 0);

  /* "SLEPc/CAPI.pyx":80
 * 
 * cdef api SlepcRG PySlepcRG_Get(object arg) except ? NULL:
 *     cdef SlepcRG retv = NULL             # <<<<<<<<<<<<<<
 *     cdef RG ob = <RG?> arg
 *     retv = ob.rg
 */
  __pyx_v_retv = NULL;

  /* "SLEPc/CAPI.pyx":81
 * cdef api SlepcRG PySlepcRG_Get(object arg) except ? NULL:
 *     cdef SlepcRG retv = NULL
 *     cdef RG ob = <RG?> arg             # <<<<<<<<<<<<<<
 *     retv = ob.rg
 *     return retv
 */
  if (!(likely(__Pyx_TypeTest(__pyx_v_arg, __pyx_ptype_8slepc4py_5SLEPc_RG)))) __PYX_ERR(22, 81, __pyx_L1_error)
  __pyx_t_1 = __pyx_v_arg;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_ob = ((struct PySlepcRGObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":82
 *     cdef SlepcRG retv = NULL
 *     cdef RG ob = <RG?> arg
 *     retv = ob.rg             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_v_ob->rg;
  __pyx_v_retv = __pyx_t_2;

  /* "SLEPc/CAPI.pyx":83
 *     cdef RG ob = <RG?> arg
 *     retv = ob.rg
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = __pyx_v_retv;
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":79
 *     return retv
 * 
 * cdef api SlepcRG PySlepcRG_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcRG retv = NULL
 *     cdef RG ob = <RG?> arg
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcRG_Get", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":89
 * # -- EPS --
 * 
 * cdef api object PySlepcEPS_New(SlepcEPS arg):             # <<<<<<<<<<<<<<
 *     cdef EPS retv = EPS()
 *     setref(&retv.eps, arg)
 */

static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcEPS_New(EPS __pyx_v_arg) {
  struct PySlepcEPSObject *__pyx_v_retv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcEPS_New", 0);

  /* "SLEPc/CAPI.pyx":90
 * 
 * cdef api object PySlepcEPS_New(SlepcEPS arg):
 *     cdef EPS retv = EPS()             # <<<<<<<<<<<<<<
 *     setref(&retv.eps, arg)
 *     return retv
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 90, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_retv = ((struct PySlepcEPSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":91
 * cdef api object PySlepcEPS_New(SlepcEPS arg):
 *     cdef EPS retv = EPS()
 *     setref(&retv.eps, arg)             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_setref((&__pyx_v_retv->eps), __pyx_v_arg); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(22, 91, __pyx_L1_error)

  /* "SLEPc/CAPI.pyx":92
 *     cdef EPS retv = EPS()
 *     setref(&retv.eps, arg)
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * cdef api SlepcEPS PySlepcEPS_Get(object arg) except ? NULL:
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_retv));
  __pyx_r = ((PyObject *)__pyx_v_retv);
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":89
 * # -- EPS --
 * 
 * cdef api object PySlepcEPS_New(SlepcEPS arg):             # <<<<<<<<<<<<<<
 *     cdef EPS retv = EPS()
 *     setref(&retv.eps, arg)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcEPS_New", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_retv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":94
 *     return retv
 * 
 * cdef api SlepcEPS PySlepcEPS_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcEPS retv = NULL
 *     cdef EPS ob = <EPS?> arg
 */

static EPS __pyx_f_8slepc4py_5SLEPc_PySlepcEPS_Get(PyObject *__pyx_v_arg) {
  EPS __pyx_v_retv;
  struct PySlepcEPSObject *__pyx_v_ob = 0;
  EPS __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  EPS __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcEPS_Get", 0);

  /* "SLEPc/CAPI.pyx":95
 * 
 * cdef api SlepcEPS PySlepcEPS_Get(object arg) except ? NULL:
 *     cdef SlepcEPS retv = NULL             # <<<<<<<<<<<<<<
 *     cdef EPS ob = <EPS?> arg
 *     retv = ob.eps
 */
  __pyx_v_retv = NULL;

  /* "SLEPc/CAPI.pyx":96
 * cdef api SlepcEPS PySlepcEPS_Get(object arg) except ? NULL:
 *     cdef SlepcEPS retv = NULL
 *     cdef EPS ob = <EPS?> arg             # <<<<<<<<<<<<<<
 *     retv = ob.eps
 *     return retv
 */
  if (!(likely(__Pyx_TypeTest(__pyx_v_arg, __pyx_ptype_8slepc4py_5SLEPc_EPS)))) __PYX_ERR(22, 96, __pyx_L1_error)
  __pyx_t_1 = __pyx_v_arg;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_ob = ((struct PySlepcEPSObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":97
 *     cdef SlepcEPS retv = NULL
 *     cdef EPS ob = <EPS?> arg
 *     retv = ob.eps             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_v_ob->eps;
  __pyx_v_retv = __pyx_t_2;

  /* "SLEPc/CAPI.pyx":98
 *     cdef EPS ob = <EPS?> arg
 *     retv = ob.eps
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = __pyx_v_retv;
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":94
 *     return retv
 * 
 * cdef api SlepcEPS PySlepcEPS_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcEPS retv = NULL
 *     cdef EPS ob = <EPS?> arg
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcEPS_Get", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":104
 * # -- SVD --
 * 
 * cdef api object PySlepcSVD_New(SlepcSVD arg):             # <<<<<<<<<<<<<<
 *     cdef SVD retv = SVD()
 *     setref(&retv.svd, arg)
 */

static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcSVD_New(SVD __pyx_v_arg) {
  struct PySlepcSVDObject *__pyx_v_retv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcSVD_New", 0);

  /* "SLEPc/CAPI.pyx":105
 * 
 * cdef api object PySlepcSVD_New(SlepcSVD arg):
 *     cdef SVD retv = SVD()             # <<<<<<<<<<<<<<
 *     setref(&retv.svd, arg)
 *     return retv
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_SVD)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 105, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_retv = ((struct PySlepcSVDObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":106
 * cdef api object PySlepcSVD_New(SlepcSVD arg):
 *     cdef SVD retv = SVD()
 *     setref(&retv.svd, arg)             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_setref((&__pyx_v_retv->svd), __pyx_v_arg); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(22, 106, __pyx_L1_error)

  /* "SLEPc/CAPI.pyx":107
 *     cdef SVD retv = SVD()
 *     setref(&retv.svd, arg)
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * cdef api SlepcSVD PySlepcSVD_Get(object arg) except ? NULL:
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_retv));
  __pyx_r = ((PyObject *)__pyx_v_retv);
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":104
 * # -- SVD --
 * 
 * cdef api object PySlepcSVD_New(SlepcSVD arg):             # <<<<<<<<<<<<<<
 *     cdef SVD retv = SVD()
 *     setref(&retv.svd, arg)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcSVD_New", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_retv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":109
 *     return retv
 * 
 * cdef api SlepcSVD PySlepcSVD_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcSVD retv = NULL
 *     cdef SVD ob = <SVD?> arg
 */

static SVD __pyx_f_8slepc4py_5SLEPc_PySlepcSVD_Get(PyObject *__pyx_v_arg) {
  SVD __pyx_v_retv;
  struct PySlepcSVDObject *__pyx_v_ob = 0;
  SVD __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  SVD __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcSVD_Get", 0);

  /* "SLEPc/CAPI.pyx":110
 * 
 * cdef api SlepcSVD PySlepcSVD_Get(object arg) except ? NULL:
 *     cdef SlepcSVD retv = NULL             # <<<<<<<<<<<<<<
 *     cdef SVD ob = <SVD?> arg
 *     retv = ob.svd
 */
  __pyx_v_retv = NULL;

  /* "SLEPc/CAPI.pyx":111
 * cdef api SlepcSVD PySlepcSVD_Get(object arg) except ? NULL:
 *     cdef SlepcSVD retv = NULL
 *     cdef SVD ob = <SVD?> arg             # <<<<<<<<<<<<<<
 *     retv = ob.svd
 *     return retv
 */
  if (!(likely(__Pyx_TypeTest(__pyx_v_arg, __pyx_ptype_8slepc4py_5SLEPc_SVD)))) __PYX_ERR(22, 111, __pyx_L1_error)
  __pyx_t_1 = __pyx_v_arg;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_ob = ((struct PySlepcSVDObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":112
 *     cdef SlepcSVD retv = NULL
 *     cdef SVD ob = <SVD?> arg
 *     retv = ob.svd             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_v_ob->svd;
  __pyx_v_retv = __pyx_t_2;

  /* "SLEPc/CAPI.pyx":113
 *     cdef SVD ob = <SVD?> arg
 *     retv = ob.svd
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = __pyx_v_retv;
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":109
 *     return retv
 * 
 * cdef api SlepcSVD PySlepcSVD_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcSVD retv = NULL
 *     cdef SVD ob = <SVD?> arg
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcSVD_Get", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":119
 * # -- PEP --
 * 
 * cdef api object PySlepcPEP_New(SlepcPEP arg):             # <<<<<<<<<<<<<<
 *     cdef PEP retv = PEP()
 *     setref(&retv.pep, arg)
 */

static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcPEP_New(PEP __pyx_v_arg) {
  struct PySlepcPEPObject *__pyx_v_retv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcPEP_New", 0);

  /* "SLEPc/CAPI.pyx":120
 * 
 * cdef api object PySlepcPEP_New(SlepcPEP arg):
 *     cdef PEP retv = PEP()             # <<<<<<<<<<<<<<
 *     setref(&retv.pep, arg)
 *     return retv
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 120, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_retv = ((struct PySlepcPEPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":121
 * cdef api object PySlepcPEP_New(SlepcPEP arg):
 *     cdef PEP retv = PEP()
 *     setref(&retv.pep, arg)             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_setref((&__pyx_v_retv->pep), __pyx_v_arg); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(22, 121, __pyx_L1_error)

  /* "SLEPc/CAPI.pyx":122
 *     cdef PEP retv = PEP()
 *     setref(&retv.pep, arg)
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * cdef api SlepcPEP PySlepcPEP_Get(object arg) except ? NULL:
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_retv));
  __pyx_r = ((PyObject *)__pyx_v_retv);
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":119
 * # -- PEP --
 * 
 * cdef api object PySlepcPEP_New(SlepcPEP arg):             # <<<<<<<<<<<<<<
 *     cdef PEP retv = PEP()
 *     setref(&retv.pep, arg)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcPEP_New", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_retv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":124
 *     return retv
 * 
 * cdef api SlepcPEP PySlepcPEP_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcPEP retv = NULL
 *     cdef PEP ob = <PEP?> arg
 */

static PEP __pyx_f_8slepc4py_5SLEPc_PySlepcPEP_Get(PyObject *__pyx_v_arg) {
  PEP __pyx_v_retv;
  struct PySlepcPEPObject *__pyx_v_ob = 0;
  PEP __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PEP __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcPEP_Get", 0);

  /* "SLEPc/CAPI.pyx":125
 * 
 * cdef api SlepcPEP PySlepcPEP_Get(object arg) except ? NULL:
 *     cdef SlepcPEP retv = NULL             # <<<<<<<<<<<<<<
 *     cdef PEP ob = <PEP?> arg
 *     retv = ob.pep
 */
  __pyx_v_retv = NULL;

  /* "SLEPc/CAPI.pyx":126
 * cdef api SlepcPEP PySlepcPEP_Get(object arg) except ? NULL:
 *     cdef SlepcPEP retv = NULL
 *     cdef PEP ob = <PEP?> arg             # <<<<<<<<<<<<<<
 *     retv = ob.pep
 *     return retv
 */
  if (!(likely(__Pyx_TypeTest(__pyx_v_arg, __pyx_ptype_8slepc4py_5SLEPc_PEP)))) __PYX_ERR(22, 126, __pyx_L1_error)
  __pyx_t_1 = __pyx_v_arg;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_ob = ((struct PySlepcPEPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":127
 *     cdef SlepcPEP retv = NULL
 *     cdef PEP ob = <PEP?> arg
 *     retv = ob.pep             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_v_ob->pep;
  __pyx_v_retv = __pyx_t_2;

  /* "SLEPc/CAPI.pyx":128
 *     cdef PEP ob = <PEP?> arg
 *     retv = ob.pep
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = __pyx_v_retv;
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":124
 *     return retv
 * 
 * cdef api SlepcPEP PySlepcPEP_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcPEP retv = NULL
 *     cdef PEP ob = <PEP?> arg
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcPEP_Get", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":134
 * # -- NEP --
 * 
 * cdef api object PySlepcNEP_New(SlepcNEP arg):             # <<<<<<<<<<<<<<
 *     cdef NEP retv = NEP()
 *     setref(&retv.nep, arg)
 */

static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcNEP_New(NEP __pyx_v_arg) {
  struct PySlepcNEPObject *__pyx_v_retv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcNEP_New", 0);

  /* "SLEPc/CAPI.pyx":135
 * 
 * cdef api object PySlepcNEP_New(SlepcNEP arg):
 *     cdef NEP retv = NEP()             # <<<<<<<<<<<<<<
 *     setref(&retv.nep, arg)
 *     return retv
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_NEP)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 135, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_retv = ((struct PySlepcNEPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":136
 * cdef api object PySlepcNEP_New(SlepcNEP arg):
 *     cdef NEP retv = NEP()
 *     setref(&retv.nep, arg)             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_setref((&__pyx_v_retv->nep), __pyx_v_arg); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(22, 136, __pyx_L1_error)

  /* "SLEPc/CAPI.pyx":137
 *     cdef NEP retv = NEP()
 *     setref(&retv.nep, arg)
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * cdef api SlepcNEP PySlepcNEP_Get(object arg) except ? NULL:
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_retv));
  __pyx_r = ((PyObject *)__pyx_v_retv);
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":134
 * # -- NEP --
 * 
 * cdef api object PySlepcNEP_New(SlepcNEP arg):             # <<<<<<<<<<<<<<
 *     cdef NEP retv = NEP()
 *     setref(&retv.nep, arg)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcNEP_New", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_retv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":139
 *     return retv
 * 
 * cdef api SlepcNEP PySlepcNEP_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcNEP retv = NULL
 *     cdef NEP ob = <NEP?> arg
 */

static NEP __pyx_f_8slepc4py_5SLEPc_PySlepcNEP_Get(PyObject *__pyx_v_arg) {
  NEP __pyx_v_retv;
  struct PySlepcNEPObject *__pyx_v_ob = 0;
  NEP __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  NEP __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcNEP_Get", 0);

  /* "SLEPc/CAPI.pyx":140
 * 
 * cdef api SlepcNEP PySlepcNEP_Get(object arg) except ? NULL:
 *     cdef SlepcNEP retv = NULL             # <<<<<<<<<<<<<<
 *     cdef NEP ob = <NEP?> arg
 *     retv = ob.nep
 */
  __pyx_v_retv = NULL;

  /* "SLEPc/CAPI.pyx":141
 * cdef api SlepcNEP PySlepcNEP_Get(object arg) except ? NULL:
 *     cdef SlepcNEP retv = NULL
 *     cdef NEP ob = <NEP?> arg             # <<<<<<<<<<<<<<
 *     retv = ob.nep
 *     return retv
 */
  if (!(likely(__Pyx_TypeTest(__pyx_v_arg, __pyx_ptype_8slepc4py_5SLEPc_NEP)))) __PYX_ERR(22, 141, __pyx_L1_error)
  __pyx_t_1 = __pyx_v_arg;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_ob = ((struct PySlepcNEPObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":142
 *     cdef SlepcNEP retv = NULL
 *     cdef NEP ob = <NEP?> arg
 *     retv = ob.nep             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_v_ob->nep;
  __pyx_v_retv = __pyx_t_2;

  /* "SLEPc/CAPI.pyx":143
 *     cdef NEP ob = <NEP?> arg
 *     retv = ob.nep
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = __pyx_v_retv;
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":139
 *     return retv
 * 
 * cdef api SlepcNEP PySlepcNEP_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcNEP retv = NULL
 *     cdef NEP ob = <NEP?> arg
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcNEP_Get", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":149
 * # -- MFN --
 * 
 * cdef api object PySlepcMFN_New(SlepcMFN arg):             # <<<<<<<<<<<<<<
 *     cdef MFN retv = MFN()
 *     setref(&retv.mfn, arg)
 */

static PyObject *__pyx_f_8slepc4py_5SLEPc_PySlepcMFN_New(MFN __pyx_v_arg) {
  struct PySlepcMFNObject *__pyx_v_retv = 0;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcMFN_New", 0);

  /* "SLEPc/CAPI.pyx":150
 * 
 * cdef api object PySlepcMFN_New(SlepcMFN arg):
 *     cdef MFN retv = MFN()             # <<<<<<<<<<<<<<
 *     setref(&retv.mfn, arg)
 *     return retv
 */
  __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_MFN)); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 150, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_retv = ((struct PySlepcMFNObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":151
 * cdef api object PySlepcMFN_New(SlepcMFN arg):
 *     cdef MFN retv = MFN()
 *     setref(&retv.mfn, arg)             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_setref((&__pyx_v_retv->mfn), __pyx_v_arg); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(22, 151, __pyx_L1_error)

  /* "SLEPc/CAPI.pyx":152
 *     cdef MFN retv = MFN()
 *     setref(&retv.mfn, arg)
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * cdef api SlepcMFN PySlepcMFN_Get(object arg) except ? NULL:
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_retv));
  __pyx_r = ((PyObject *)__pyx_v_retv);
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":149
 * # -- MFN --
 * 
 * cdef api object PySlepcMFN_New(SlepcMFN arg):             # <<<<<<<<<<<<<<
 *     cdef MFN retv = MFN()
 *     setref(&retv.mfn, arg)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcMFN_New", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_retv);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/CAPI.pyx":154
 *     return retv
 * 
 * cdef api SlepcMFN PySlepcMFN_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcMFN retv = NULL
 *     cdef MFN ob = <MFN?> arg
 */

static MFN __pyx_f_8slepc4py_5SLEPc_PySlepcMFN_Get(PyObject *__pyx_v_arg) {
  MFN __pyx_v_retv;
  struct PySlepcMFNObject *__pyx_v_ob = 0;
  MFN __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  MFN __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("PySlepcMFN_Get", 0);

  /* "SLEPc/CAPI.pyx":155
 * 
 * cdef api SlepcMFN PySlepcMFN_Get(object arg) except ? NULL:
 *     cdef SlepcMFN retv = NULL             # <<<<<<<<<<<<<<
 *     cdef MFN ob = <MFN?> arg
 *     retv = ob.mfn
 */
  __pyx_v_retv = NULL;

  /* "SLEPc/CAPI.pyx":156
 * cdef api SlepcMFN PySlepcMFN_Get(object arg) except ? NULL:
 *     cdef SlepcMFN retv = NULL
 *     cdef MFN ob = <MFN?> arg             # <<<<<<<<<<<<<<
 *     retv = ob.mfn
 *     return retv
 */
  if (!(likely(__Pyx_TypeTest(__pyx_v_arg, __pyx_ptype_8slepc4py_5SLEPc_MFN)))) __PYX_ERR(22, 156, __pyx_L1_error)
  __pyx_t_1 = __pyx_v_arg;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_ob = ((struct PySlepcMFNObject *)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "SLEPc/CAPI.pyx":157
 *     cdef SlepcMFN retv = NULL
 *     cdef MFN ob = <MFN?> arg
 *     retv = ob.mfn             # <<<<<<<<<<<<<<
 *     return retv
 * 
 */
  __pyx_t_2 = __pyx_v_ob->mfn;
  __pyx_v_retv = __pyx_t_2;

  /* "SLEPc/CAPI.pyx":158
 *     cdef MFN ob = <MFN?> arg
 *     retv = ob.mfn
 *     return retv             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_r = __pyx_v_retv;
  goto __pyx_L0;

  /* "SLEPc/CAPI.pyx":154
 *     return retv
 * 
 * cdef api SlepcMFN PySlepcMFN_Get(object arg) except ? NULL:             # <<<<<<<<<<<<<<
 *     cdef SlepcMFN retv = NULL
 *     cdef MFN ob = <MFN?> arg
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("slepc4py.SLEPc.PySlepcMFN_Get", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ob);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":199
 *     int fprintf(FILE *, char *, ...)
 * 
 * cdef int initialize(object args) except -1:             # <<<<<<<<<<<<<<
 *     if (<int>SlepcInitializeCalled): return 1
 *     if (<int>SlepcFinalizeCalled):   return 0
 */

static int __pyx_f_8slepc4py_5SLEPc_initialize(CYTHON_UNUSED PyObject *__pyx_v_args) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("initialize", 0);

  /* "SLEPc/SLEPc.pyx":200
 * 
 * cdef int initialize(object args) except -1:
 *     if (<int>SlepcInitializeCalled): return 1             # <<<<<<<<<<<<<<
 *     if (<int>SlepcFinalizeCalled):   return 0
 *     # initialize SLEPC
 */
  __pyx_t_1 = (((int)SlepcInitializeCalled) != 0);
  if (__pyx_t_1) {
    __pyx_r = 1;
    goto __pyx_L0;
  }

  /* "SLEPc/SLEPc.pyx":201
 * cdef int initialize(object args) except -1:
 *     if (<int>SlepcInitializeCalled): return 1
 *     if (<int>SlepcFinalizeCalled):   return 0             # <<<<<<<<<<<<<<
 *     # initialize SLEPC
 *     CHKERR( SlepcInitialize(NULL, NULL, NULL, NULL) )
 */
  __pyx_t_1 = (((int)SlepcFinalizeCalled) != 0);
  if (__pyx_t_1) {
    __pyx_r = 0;
    goto __pyx_L0;
  }

  /* "SLEPc/SLEPc.pyx":203
 *     if (<int>SlepcFinalizeCalled):   return 0
 *     # initialize SLEPC
 *     CHKERR( SlepcInitialize(NULL, NULL, NULL, NULL) )             # <<<<<<<<<<<<<<
 *     # register finalization function
 *     if Py_AtExit(finalize) < 0:
 */
  __pyx_t_2 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SlepcInitialize(NULL, NULL, NULL, NULL)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(4, 203, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":205
 *     CHKERR( SlepcInitialize(NULL, NULL, NULL, NULL) )
 *     # register finalization function
 *     if Py_AtExit(finalize) < 0:             # <<<<<<<<<<<<<<
 *         PySys_WriteStderr(b"warning: could not register %s with Py_AtExit()",
 *                           b"SlepcFinalize()")
 */
  __pyx_t_1 = ((Py_AtExit(__pyx_f_8slepc4py_5SLEPc_finalize) < 0) != 0);
  if (__pyx_t_1) {

    /* "SLEPc/SLEPc.pyx":206
 *     # register finalization function
 *     if Py_AtExit(finalize) < 0:
 *         PySys_WriteStderr(b"warning: could not register %s with Py_AtExit()",             # <<<<<<<<<<<<<<
 *                           b"SlepcFinalize()")
 *     return 1 # and we are done, enjoy !!
 */
    PySys_WriteStderr(((char *)"warning: could not register %s with Py_AtExit()"), ((char *)"SlepcFinalize()"));

    /* "SLEPc/SLEPc.pyx":205
 *     CHKERR( SlepcInitialize(NULL, NULL, NULL, NULL) )
 *     # register finalization function
 *     if Py_AtExit(finalize) < 0:             # <<<<<<<<<<<<<<
 *         PySys_WriteStderr(b"warning: could not register %s with Py_AtExit()",
 *                           b"SlepcFinalize()")
 */
  }

  /* "SLEPc/SLEPc.pyx":208
 *         PySys_WriteStderr(b"warning: could not register %s with Py_AtExit()",
 *                           b"SlepcFinalize()")
 *     return 1 # and we are done, enjoy !!             # <<<<<<<<<<<<<<
 * 
 * from petsc4py.PETSc cimport PyPetscType_Register
 */
  __pyx_r = 1;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":199
 *     int fprintf(FILE *, char *, ...)
 * 
 * cdef int initialize(object args) except -1:             # <<<<<<<<<<<<<<
 *     if (<int>SlepcInitializeCalled): return 1
 *     if (<int>SlepcFinalizeCalled):   return 0
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.initialize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":226
 *     PetscClassId SLEPC_MFN_CLASSID "MFN_CLASSID"
 * 
 * cdef int register(char path[]) except -1:             # <<<<<<<<<<<<<<
 *     # make sure all SLEPc packages are initialized
 *     CHKERR( SlepcInitializePackageAll() )
 */

static int __pyx_f_8slepc4py_5SLEPc_register(CYTHON_UNUSED char *__pyx_v_path) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("register", 0);

  /* "SLEPc/SLEPc.pyx":228
 * cdef int register(char path[]) except -1:
 *     # make sure all SLEPc packages are initialized
 *     CHKERR( SlepcInitializePackageAll() )             # <<<<<<<<<<<<<<
 *     # register Python types
 *     PyPetscType_Register(SLEPC_ST_CLASSID,  ST)
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_CHKERR(SlepcInitializePackageAll()); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 228, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":230
 *     CHKERR( SlepcInitializePackageAll() )
 *     # register Python types
 *     PyPetscType_Register(SLEPC_ST_CLASSID,  ST)             # <<<<<<<<<<<<<<
 *     PyPetscType_Register(SLEPC_BV_CLASSID,  BV)
 *     PyPetscType_Register(SLEPC_DS_CLASSID,  DS)
 */
  __pyx_t_1 = __pyx_f_8petsc4py_5PETSc_PyPetscType_Register(ST_CLASSID, __pyx_ptype_8slepc4py_5SLEPc_ST); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 230, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":231
 *     # register Python types
 *     PyPetscType_Register(SLEPC_ST_CLASSID,  ST)
 *     PyPetscType_Register(SLEPC_BV_CLASSID,  BV)             # <<<<<<<<<<<<<<
 *     PyPetscType_Register(SLEPC_DS_CLASSID,  DS)
 *     PyPetscType_Register(SLEPC_FN_CLASSID,  FN)
 */
  __pyx_t_1 = __pyx_f_8petsc4py_5PETSc_PyPetscType_Register(BV_CLASSID, __pyx_ptype_8slepc4py_5SLEPc_BV); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 231, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":232
 *     PyPetscType_Register(SLEPC_ST_CLASSID,  ST)
 *     PyPetscType_Register(SLEPC_BV_CLASSID,  BV)
 *     PyPetscType_Register(SLEPC_DS_CLASSID,  DS)             # <<<<<<<<<<<<<<
 *     PyPetscType_Register(SLEPC_FN_CLASSID,  FN)
 *     PyPetscType_Register(SLEPC_RG_CLASSID,  RG)
 */
  __pyx_t_1 = __pyx_f_8petsc4py_5PETSc_PyPetscType_Register(DS_CLASSID, __pyx_ptype_8slepc4py_5SLEPc_DS); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 232, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":233
 *     PyPetscType_Register(SLEPC_BV_CLASSID,  BV)
 *     PyPetscType_Register(SLEPC_DS_CLASSID,  DS)
 *     PyPetscType_Register(SLEPC_FN_CLASSID,  FN)             # <<<<<<<<<<<<<<
 *     PyPetscType_Register(SLEPC_RG_CLASSID,  RG)
 *     PyPetscType_Register(SLEPC_EPS_CLASSID, EPS)
 */
  __pyx_t_1 = __pyx_f_8petsc4py_5PETSc_PyPetscType_Register(FN_CLASSID, __pyx_ptype_8slepc4py_5SLEPc_FN); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 233, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":234
 *     PyPetscType_Register(SLEPC_DS_CLASSID,  DS)
 *     PyPetscType_Register(SLEPC_FN_CLASSID,  FN)
 *     PyPetscType_Register(SLEPC_RG_CLASSID,  RG)             # <<<<<<<<<<<<<<
 *     PyPetscType_Register(SLEPC_EPS_CLASSID, EPS)
 *     PyPetscType_Register(SLEPC_SVD_CLASSID, SVD)
 */
  __pyx_t_1 = __pyx_f_8petsc4py_5PETSc_PyPetscType_Register(RG_CLASSID, __pyx_ptype_8slepc4py_5SLEPc_RG); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 234, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":235
 *     PyPetscType_Register(SLEPC_FN_CLASSID,  FN)
 *     PyPetscType_Register(SLEPC_RG_CLASSID,  RG)
 *     PyPetscType_Register(SLEPC_EPS_CLASSID, EPS)             # <<<<<<<<<<<<<<
 *     PyPetscType_Register(SLEPC_SVD_CLASSID, SVD)
 *     PyPetscType_Register(SLEPC_PEP_CLASSID, PEP)
 */
  __pyx_t_1 = __pyx_f_8petsc4py_5PETSc_PyPetscType_Register(EPS_CLASSID, __pyx_ptype_8slepc4py_5SLEPc_EPS); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 235, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":236
 *     PyPetscType_Register(SLEPC_RG_CLASSID,  RG)
 *     PyPetscType_Register(SLEPC_EPS_CLASSID, EPS)
 *     PyPetscType_Register(SLEPC_SVD_CLASSID, SVD)             # <<<<<<<<<<<<<<
 *     PyPetscType_Register(SLEPC_PEP_CLASSID, PEP)
 *     PyPetscType_Register(SLEPC_NEP_CLASSID, NEP)
 */
  __pyx_t_1 = __pyx_f_8petsc4py_5PETSc_PyPetscType_Register(SVD_CLASSID, __pyx_ptype_8slepc4py_5SLEPc_SVD); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 236, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":237
 *     PyPetscType_Register(SLEPC_EPS_CLASSID, EPS)
 *     PyPetscType_Register(SLEPC_SVD_CLASSID, SVD)
 *     PyPetscType_Register(SLEPC_PEP_CLASSID, PEP)             # <<<<<<<<<<<<<<
 *     PyPetscType_Register(SLEPC_NEP_CLASSID, NEP)
 *     PyPetscType_Register(SLEPC_MFN_CLASSID, MFN)
 */
  __pyx_t_1 = __pyx_f_8petsc4py_5PETSc_PyPetscType_Register(PEP_CLASSID, __pyx_ptype_8slepc4py_5SLEPc_PEP); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 237, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":238
 *     PyPetscType_Register(SLEPC_SVD_CLASSID, SVD)
 *     PyPetscType_Register(SLEPC_PEP_CLASSID, PEP)
 *     PyPetscType_Register(SLEPC_NEP_CLASSID, NEP)             # <<<<<<<<<<<<<<
 *     PyPetscType_Register(SLEPC_MFN_CLASSID, MFN)
 *     return 0
 */
  __pyx_t_1 = __pyx_f_8petsc4py_5PETSc_PyPetscType_Register(NEP_CLASSID, __pyx_ptype_8slepc4py_5SLEPc_NEP); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 238, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":239
 *     PyPetscType_Register(SLEPC_PEP_CLASSID, PEP)
 *     PyPetscType_Register(SLEPC_NEP_CLASSID, NEP)
 *     PyPetscType_Register(SLEPC_MFN_CLASSID, MFN)             # <<<<<<<<<<<<<<
 *     return 0
 * 
 */
  __pyx_t_1 = __pyx_f_8petsc4py_5PETSc_PyPetscType_Register(MFN_CLASSID, __pyx_ptype_8slepc4py_5SLEPc_MFN); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 239, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":240
 *     PyPetscType_Register(SLEPC_NEP_CLASSID, NEP)
 *     PyPetscType_Register(SLEPC_MFN_CLASSID, MFN)
 *     return 0             # <<<<<<<<<<<<<<
 * 
 * cdef void finalize() nogil:
 */
  __pyx_r = 0;
  goto __pyx_L0;

  /* "SLEPc/SLEPc.pyx":226
 *     PetscClassId SLEPC_MFN_CLASSID "MFN_CLASSID"
 * 
 * cdef int register(char path[]) except -1:             # <<<<<<<<<<<<<<
 *     # make sure all SLEPc packages are initialized
 *     CHKERR( SlepcInitializePackageAll() )
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc.register", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":242
 *     return 0
 * 
 * cdef void finalize() nogil:             # <<<<<<<<<<<<<<
 *     cdef int ierr = 0
 *     # manage SLEPc finalization
 */

static void __pyx_f_8slepc4py_5SLEPc_finalize(void) {
  int __pyx_v_ierr;
  int __pyx_t_1;

  /* "SLEPc/SLEPc.pyx":243
 * 
 * cdef void finalize() nogil:
 *     cdef int ierr = 0             # <<<<<<<<<<<<<<
 *     # manage SLEPc finalization
 *     if not (<int>SlepcInitializeCalled): return
 */
  __pyx_v_ierr = 0;

  /* "SLEPc/SLEPc.pyx":245
 *     cdef int ierr = 0
 *     # manage SLEPc finalization
 *     if not (<int>SlepcInitializeCalled): return             # <<<<<<<<<<<<<<
 *     if (<int>SlepcFinalizeCalled): return
 *     # finalize SLEPc
 */
  __pyx_t_1 = ((!(((int)SlepcInitializeCalled) != 0)) != 0);
  if (__pyx_t_1) {
    goto __pyx_L0;
  }

  /* "SLEPc/SLEPc.pyx":246
 *     # manage SLEPc finalization
 *     if not (<int>SlepcInitializeCalled): return
 *     if (<int>SlepcFinalizeCalled): return             # <<<<<<<<<<<<<<
 *     # finalize SLEPc
 *     ierr = SlepcFinalize()
 */
  __pyx_t_1 = (((int)SlepcFinalizeCalled) != 0);
  if (__pyx_t_1) {
    goto __pyx_L0;
  }

  /* "SLEPc/SLEPc.pyx":248
 *     if (<int>SlepcFinalizeCalled): return
 *     # finalize SLEPc
 *     ierr = SlepcFinalize()             # <<<<<<<<<<<<<<
 *     if ierr != 0:
 *         fprintf(stderr, "SlepcFinalize() failed "
 */
  __pyx_v_ierr = SlepcFinalize();

  /* "SLEPc/SLEPc.pyx":249
 *     # finalize SLEPc
 *     ierr = SlepcFinalize()
 *     if ierr != 0:             # <<<<<<<<<<<<<<
 *         fprintf(stderr, "SlepcFinalize() failed "
 *                 "[error code: %d]\n", ierr)
 */
  __pyx_t_1 = ((__pyx_v_ierr != 0) != 0);
  if (__pyx_t_1) {

    /* "SLEPc/SLEPc.pyx":250
 *     ierr = SlepcFinalize()
 *     if ierr != 0:
 *         fprintf(stderr, "SlepcFinalize() failed "             # <<<<<<<<<<<<<<
 *                 "[error code: %d]\n", ierr)
 *     # and we are done, see you later !!
 */
    (void)(fprintf(stderr, ((char *)"SlepcFinalize() failed [error code: %d]\n"), __pyx_v_ierr));

    /* "SLEPc/SLEPc.pyx":249
 *     # finalize SLEPc
 *     ierr = SlepcFinalize()
 *     if ierr != 0:             # <<<<<<<<<<<<<<
 *         fprintf(stderr, "SlepcFinalize() failed "
 *                 "[error code: %d]\n", ierr)
 */
  }

  /* "SLEPc/SLEPc.pyx":242
 *     return 0
 * 
 * cdef void finalize() nogil:             # <<<<<<<<<<<<<<
 *     cdef int ierr = 0
 *     # manage SLEPc finalization
 */

  /* function exit code */
  __pyx_L0:;
}

/* "SLEPc/SLEPc.pyx":256
 * # -----------------------------------------------------------------------------
 * 
 * def _initialize(args=None):             # <<<<<<<<<<<<<<
 *     cdef int ready = initialize(args)
 *     if ready: register(NULL)
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_1_initialize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc__initialize[] = "_initialize(args=None)";
static PyMethodDef __pyx_mdef_8slepc4py_5SLEPc_1_initialize = {"_initialize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_1_initialize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc__initialize};
static PyObject *__pyx_pw_8slepc4py_5SLEPc_1_initialize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_args = 0;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_initialize (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_args,0};
    PyObject* values[1] = {0};
    values[0] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args);
          if (value) { values[0] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_initialize") < 0)) __PYX_ERR(4, 256, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_args = values[0];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_initialize", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(4, 256, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc._initialize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc__initialize(__pyx_self, __pyx_v_args);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc__initialize(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_args) {
  int __pyx_v_ready;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("_initialize", 0);

  /* "SLEPc/SLEPc.pyx":257
 * 
 * def _initialize(args=None):
 *     cdef int ready = initialize(args)             # <<<<<<<<<<<<<<
 *     if ready: register(NULL)
 * 
 */
  __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_initialize(__pyx_v_args); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 257, __pyx_L1_error)
  __pyx_v_ready = __pyx_t_1;

  /* "SLEPc/SLEPc.pyx":258
 * def _initialize(args=None):
 *     cdef int ready = initialize(args)
 *     if ready: register(NULL)             # <<<<<<<<<<<<<<
 * 
 * def _finalize():
 */
  __pyx_t_2 = (__pyx_v_ready != 0);
  if (__pyx_t_2) {
    __pyx_t_1 = __pyx_f_8slepc4py_5SLEPc_register(NULL); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 258, __pyx_L1_error)
  }

  /* "SLEPc/SLEPc.pyx":256
 * # -----------------------------------------------------------------------------
 * 
 * def _initialize(args=None):             # <<<<<<<<<<<<<<
 *     cdef int ready = initialize(args)
 *     if ready: register(NULL)
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_AddTraceback("slepc4py.SLEPc._initialize", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "SLEPc/SLEPc.pyx":260
 *     if ready: register(NULL)
 * 
 * def _finalize():             # <<<<<<<<<<<<<<
 *     finalize()
 * 
 */

/* Python wrapper */
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3_finalize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8slepc4py_5SLEPc_2_finalize[] = "_finalize()";
static PyMethodDef __pyx_mdef_8slepc4py_5SLEPc_3_finalize = {"_finalize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3_finalize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2_finalize};
static PyObject *__pyx_pw_8slepc4py_5SLEPc_3_finalize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_finalize (wrapper)", 0);
  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
    __Pyx_RaiseArgtupleInvalid("_finalize", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;}
  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "_finalize", 0))) return NULL;
  __pyx_r = __pyx_pf_8slepc4py_5SLEPc_2_finalize(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8slepc4py_5SLEPc_2_finalize(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_finalize", 0);

  /* "SLEPc/SLEPc.pyx":261
 * 
 * def _finalize():
 *     finalize()             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_f_8slepc4py_5SLEPc_finalize();

  /* "SLEPc/SLEPc.pyx":260
 *     if ready: register(NULL)
 * 
 * def _finalize():             # <<<<<<<<<<<<<<
 *     finalize()
 * 
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_ST __pyx_vtable_8slepc4py_5SLEPc_ST;

static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_ST(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct PySlepcSTObject *p;
  PyObject *o = __pyx_ptype_8petsc4py_5PETSc_Object->tp_new(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct PySlepcSTObject *)o);
  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Object*)__pyx_vtabptr_8slepc4py_5SLEPc_ST;
  if (unlikely(__pyx_pw_8slepc4py_5SLEPc_2ST_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_8slepc4py_5SLEPc_ST(PyObject *o) {
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
    if (PyObject_CallFinalizerFromDealloc(o)) return;
  }
  #endif
  PyObject_GC_UnTrack(o);
  PyObject_GC_Track(o);
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) __pyx_ptype_8petsc4py_5PETSc_Object->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_8slepc4py_5SLEPc_ST);
}

static int __pyx_tp_traverse_8slepc4py_5SLEPc_ST(PyObject *o, visitproc v, void *a) {
  int e;
  e = ((likely(__pyx_ptype_8petsc4py_5PETSc_Object)) ? ((__pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse) ? __pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_8slepc4py_5SLEPc_ST)); if (e) return e;
  return 0;
}

static int __pyx_tp_clear_8slepc4py_5SLEPc_ST(PyObject *o) {
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) { if (__pyx_ptype_8petsc4py_5PETSc_Object->tp_clear) __pyx_ptype_8petsc4py_5PETSc_Object->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_8slepc4py_5SLEPc_ST);
  return 0;
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2ST_shift(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2ST_5shift_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2ST_shift(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2ST_5shift_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2ST_transform(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2ST_9transform_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2ST_transform(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2ST_9transform_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2ST_mat_mode(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2ST_8mat_mode_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2ST_mat_mode(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2ST_8mat_mode_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2ST_mat_structure(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2ST_13mat_structure_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2ST_mat_structure(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2ST_13mat_structure_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2ST_ksp(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2ST_3ksp_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2ST_ksp(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2ST_3ksp_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyMethodDef __pyx_methods_8slepc4py_5SLEPc_ST[] = {
  {"view", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_3view, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_2view},
  {"destroy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_5destroy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_4destroy},
  {"reset", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_7reset, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_6reset},
  {"create", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_9create, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_8create},
  {"setType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_11setType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_10setType},
  {"getType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_13getType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_12getType},
  {"setOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_15setOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_14setOptionsPrefix},
  {"getOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_17getOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_16getOptionsPrefix},
  {"setFromOptions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_19setFromOptions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_18setFromOptions},
  {"setShift", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_21setShift, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_20setShift},
  {"getShift", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_23getShift, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_22getShift},
  {"setTransform", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_25setTransform, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_24setTransform},
  {"getTransform", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_27getTransform, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_26getTransform},
  {"setMatMode", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_29setMatMode, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_28setMatMode},
  {"getMatMode", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_31getMatMode, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_30getMatMode},
  {"setMatrices", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_33setMatrices, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_32setMatrices},
  {"getMatrices", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_35getMatrices, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_34getMatrices},
  {"setMatStructure", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_37setMatStructure, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_36setMatStructure},
  {"getMatStructure", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_39getMatStructure, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_38getMatStructure},
  {"setKSP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_41setKSP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_40setKSP},
  {"getKSP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_43getKSP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_42getKSP},
  {"setPreconditionerMat", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_45setPreconditionerMat, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_44setPreconditionerMat},
  {"getPreconditionerMat", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_47getPreconditionerMat, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_46getPreconditionerMat},
  {"setUp", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_49setUp, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_48setUp},
  {"apply", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_51apply, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_50apply},
  {"applyTranspose", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_53applyTranspose, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_52applyTranspose},
  {"applyHermitianTranspose", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_55applyHermitianTranspose, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_54applyHermitianTranspose},
  {"applyMat", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_57applyMat, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_56applyMat},
  {"getOperator", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_59getOperator, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_58getOperator},
  {"restoreOperator", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_61restoreOperator, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_60restoreOperator},
  {"setCayleyAntishift", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_63setCayleyAntishift, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_62setCayleyAntishift},
  {"getCayleyAntishift", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_65getCayleyAntishift, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_64getCayleyAntishift},
  {"setFilterInterval", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_67setFilterInterval, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_66setFilterInterval},
  {"getFilterInterval", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_69getFilterInterval, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_68getFilterInterval},
  {"setFilterRange", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_71setFilterRange, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_70setFilterRange},
  {"getFilterRange", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_73getFilterRange, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_72getFilterRange},
  {"setFilterDegree", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_75setFilterDegree, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_74setFilterDegree},
  {"getFilterDegree", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2ST_77getFilterDegree, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2ST_76getFilterDegree},
  {0, 0, 0, 0}
};

static struct PyGetSetDef __pyx_getsets_8slepc4py_5SLEPc_ST[] = {
  {(char *)"shift", __pyx_getprop_8slepc4py_5SLEPc_2ST_shift, __pyx_setprop_8slepc4py_5SLEPc_2ST_shift, (char *)0, 0},
  {(char *)"transform", __pyx_getprop_8slepc4py_5SLEPc_2ST_transform, __pyx_setprop_8slepc4py_5SLEPc_2ST_transform, (char *)0, 0},
  {(char *)"mat_mode", __pyx_getprop_8slepc4py_5SLEPc_2ST_mat_mode, __pyx_setprop_8slepc4py_5SLEPc_2ST_mat_mode, (char *)0, 0},
  {(char *)"mat_structure", __pyx_getprop_8slepc4py_5SLEPc_2ST_mat_structure, __pyx_setprop_8slepc4py_5SLEPc_2ST_mat_structure, (char *)0, 0},
  {(char *)"ksp", __pyx_getprop_8slepc4py_5SLEPc_2ST_ksp, __pyx_setprop_8slepc4py_5SLEPc_2ST_ksp, (char *)0, 0},
  {0, 0, 0, 0, 0}
};

DL_EXPORT(PyTypeObject) PySlepcST_Type = {
  PyVarObject_HEAD_INIT(0, 0)
  "slepc4py.SLEPc.ST", /*tp_name*/
  sizeof(struct PySlepcSTObject), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_8slepc4py_5SLEPc_ST, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  #if PY_MAJOR_VERSION < 3
  0, /*tp_compare*/
  #endif
  #if PY_MAJOR_VERSION >= 3
  0, /*tp_as_async*/
  #endif
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
  "\n    ST\n    ", /*tp_doc*/
  __pyx_tp_traverse_8slepc4py_5SLEPc_ST, /*tp_traverse*/
  __pyx_tp_clear_8slepc4py_5SLEPc_ST, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_8slepc4py_5SLEPc_ST, /*tp_methods*/
  0, /*tp_members*/
  __pyx_getsets_8slepc4py_5SLEPc_ST, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  0, /*tp_dictoffset*/
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_8slepc4py_5SLEPc_ST, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if PY_VERSION_HEX >= 0x030400a1
  0, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
  0, /*tp_print*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
  0, /*tp_pypy_flags*/
  #endif
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_BV __pyx_vtable_8slepc4py_5SLEPc_BV;

static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_BV(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct PySlepcBVObject *p;
  PyObject *o = __pyx_ptype_8petsc4py_5PETSc_Object->tp_new(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct PySlepcBVObject *)o);
  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Object*)__pyx_vtabptr_8slepc4py_5SLEPc_BV;
  if (unlikely(__pyx_pw_8slepc4py_5SLEPc_2BV_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_8slepc4py_5SLEPc_BV(PyObject *o) {
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
    if (PyObject_CallFinalizerFromDealloc(o)) return;
  }
  #endif
  PyObject_GC_UnTrack(o);
  PyObject_GC_Track(o);
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) __pyx_ptype_8petsc4py_5PETSc_Object->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_8slepc4py_5SLEPc_BV);
}

static int __pyx_tp_traverse_8slepc4py_5SLEPc_BV(PyObject *o, visitproc v, void *a) {
  int e;
  e = ((likely(__pyx_ptype_8petsc4py_5PETSc_Object)) ? ((__pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse) ? __pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_8slepc4py_5SLEPc_BV)); if (e) return e;
  return 0;
}

static int __pyx_tp_clear_8slepc4py_5SLEPc_BV(PyObject *o) {
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) { if (__pyx_ptype_8petsc4py_5PETSc_Object->tp_clear) __pyx_ptype_8petsc4py_5PETSc_Object->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_8slepc4py_5SLEPc_BV);
  return 0;
}

static PyMethodDef __pyx_methods_8slepc4py_5SLEPc_BV[] = {
  {"view", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_3view, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_2view},
  {"destroy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_5destroy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_4destroy},
  {"create", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_7create, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_6create},
  {"createFromMat", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_9createFromMat, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_8createFromMat},
  {"createMat", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_11createMat, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_10createMat},
  {"duplicate", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_13duplicate, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_12duplicate},
  {"duplicateResize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_15duplicateResize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_14duplicateResize},
  {"copy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_17copy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_16copy},
  {"setType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_19setType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_18setType},
  {"getType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_21getType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_20getType},
  {"setSizes", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_23setSizes, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_22setSizes},
  {"setSizesFromVec", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_25setSizesFromVec, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_24setSizesFromVec},
  {"getSizes", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_27getSizes, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_26getSizes},
  {"setOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_29setOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_28setOptionsPrefix},
  {"getOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_31getOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_30getOptionsPrefix},
  {"setFromOptions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_33setFromOptions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_32setFromOptions},
  {"getOrthogonalization", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_35getOrthogonalization, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_34getOrthogonalization},
  {"setOrthogonalization", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_37setOrthogonalization, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_36setOrthogonalization},
  {"getMatMultMethod", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_39getMatMultMethod, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_38getMatMultMethod},
  {"setMatMultMethod", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_41setMatMultMethod, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_40setMatMultMethod},
  {"getMatrix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_43getMatrix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_42getMatrix},
  {"setMatrix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_45setMatrix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_44setMatrix},
  {"applyMatrix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_47applyMatrix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_46applyMatrix},
  {"setActiveColumns", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_49setActiveColumns, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_48setActiveColumns},
  {"getActiveColumns", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_51getActiveColumns, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_50getActiveColumns},
  {"scaleColumn", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_53scaleColumn, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_52scaleColumn},
  {"scale", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_55scale, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_54scale},
  {"insertVec", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_57insertVec, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_56insertVec},
  {"insertVecs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_59insertVecs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_58insertVecs},
  {"insertConstraints", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_61insertConstraints, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_60insertConstraints},
  {"setNumConstraints", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_63setNumConstraints, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_62setNumConstraints},
  {"getNumConstraints", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_65getNumConstraints, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_64getNumConstraints},
  {"createVec", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_67createVec, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_66createVec},
  {"copyVec", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_69copyVec, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_68copyVec},
  {"copyColumn", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_71copyColumn, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_70copyColumn},
  {"setDefiniteTolerance", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_73setDefiniteTolerance, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_72setDefiniteTolerance},
  {"getDefiniteTolerance", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_75getDefiniteTolerance, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_74getDefiniteTolerance},
  {"dotVec", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_77dotVec, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_76dotVec},
  {"dotColumn", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_79dotColumn, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_78dotColumn},
  {"getColumn", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_81getColumn, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_80getColumn},
  {"restoreColumn", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_83restoreColumn, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_82restoreColumn},
  {"getMat", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_85getMat, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_84getMat},
  {"restoreMat", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_87restoreMat, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_86restoreMat},
  {"dot", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_89dot, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_88dot},
  {"matProject", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_91matProject, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_90matProject},
  {"matMult", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_93matMult, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_92matMult},
  {"matMultHermitianTranspose", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_95matMultHermitianTranspose, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_94matMultHermitianTranspose},
  {"matMultColumn", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_97matMultColumn, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_96matMultColumn},
  {"matMultTransposeColumn", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_99matMultTransposeColumn, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_98matMultTransposeColumn},
  {"matMultHermitianTransposeColumn", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_101matMultHermitianTransposeColumn, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_100matMultHermitianTransposeColumn},
  {"mult", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_103mult, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_102mult},
  {"multInPlace", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_105multInPlace, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_104multInPlace},
  {"multColumn", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_107multColumn, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_106multColumn},
  {"multVec", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_109multVec, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_108multVec},
  {"normColumn", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_111normColumn, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_110normColumn},
  {"norm", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_113norm, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_112norm},
  {"resize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_115resize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_114resize},
  {"setRandom", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_117setRandom, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_116setRandom},
  {"setRandomNormal", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_119setRandomNormal, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_118setRandomNormal},
  {"setRandomSign", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_121setRandomSign, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_120setRandomSign},
  {"setRandomColumn", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_123setRandomColumn, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_122setRandomColumn},
  {"setRandomCond", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_125setRandomCond, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_124setRandomCond},
  {"setRandomContext", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_127setRandomContext, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_126setRandomContext},
  {"getRandomContext", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_129getRandomContext, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_128getRandomContext},
  {"orthogonalizeVec", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_131orthogonalizeVec, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_130orthogonalizeVec},
  {"orthogonalizeColumn", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_133orthogonalizeColumn, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_132orthogonalizeColumn},
  {"orthonormalizeColumn", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_135orthonormalizeColumn, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_134orthonormalizeColumn},
  {"orthogonalize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2BV_137orthogonalize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2BV_136orthogonalize},
  {0, 0, 0, 0}
};

DL_EXPORT(PyTypeObject) PySlepcBV_Type = {
  PyVarObject_HEAD_INIT(0, 0)
  "slepc4py.SLEPc.BV", /*tp_name*/
  sizeof(struct PySlepcBVObject), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_8slepc4py_5SLEPc_BV, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  #if PY_MAJOR_VERSION < 3
  0, /*tp_compare*/
  #endif
  #if PY_MAJOR_VERSION >= 3
  0, /*tp_as_async*/
  #endif
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
  "\n    BV\n    ", /*tp_doc*/
  __pyx_tp_traverse_8slepc4py_5SLEPc_BV, /*tp_traverse*/
  __pyx_tp_clear_8slepc4py_5SLEPc_BV, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_8slepc4py_5SLEPc_BV, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  0, /*tp_dictoffset*/
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_8slepc4py_5SLEPc_BV, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if PY_VERSION_HEX >= 0x030400a1
  0, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
  0, /*tp_print*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
  0, /*tp_pypy_flags*/
  #endif
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_DS __pyx_vtable_8slepc4py_5SLEPc_DS;

static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_DS(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct PySlepcDSObject *p;
  PyObject *o = __pyx_ptype_8petsc4py_5PETSc_Object->tp_new(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct PySlepcDSObject *)o);
  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Object*)__pyx_vtabptr_8slepc4py_5SLEPc_DS;
  if (unlikely(__pyx_pw_8slepc4py_5SLEPc_2DS_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_8slepc4py_5SLEPc_DS(PyObject *o) {
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
    if (PyObject_CallFinalizerFromDealloc(o)) return;
  }
  #endif
  PyObject_GC_UnTrack(o);
  PyObject_GC_Track(o);
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) __pyx_ptype_8petsc4py_5PETSc_Object->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_8slepc4py_5SLEPc_DS);
}

static int __pyx_tp_traverse_8slepc4py_5SLEPc_DS(PyObject *o, visitproc v, void *a) {
  int e;
  e = ((likely(__pyx_ptype_8petsc4py_5PETSc_Object)) ? ((__pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse) ? __pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_8slepc4py_5SLEPc_DS)); if (e) return e;
  return 0;
}

static int __pyx_tp_clear_8slepc4py_5SLEPc_DS(PyObject *o) {
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) { if (__pyx_ptype_8petsc4py_5PETSc_Object->tp_clear) __pyx_ptype_8petsc4py_5PETSc_Object->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_8slepc4py_5SLEPc_DS);
  return 0;
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2DS_state(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2DS_5state_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2DS_state(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2DS_5state_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2DS_parallel(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2DS_8parallel_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2DS_parallel(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2DS_8parallel_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2DS_block_size(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2DS_10block_size_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2DS_block_size(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2DS_10block_size_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2DS_method(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2DS_6method_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2DS_method(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2DS_6method_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2DS_compact(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2DS_7compact_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2DS_compact(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2DS_7compact_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2DS_extra_row(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2DS_9extra_row_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2DS_extra_row(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2DS_9extra_row_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2DS_refined(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2DS_7refined_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2DS_refined(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2DS_7refined_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyMethodDef __pyx_methods_8slepc4py_5SLEPc_DS[] = {
  {"view", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_3view, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_2view},
  {"destroy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_5destroy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_4destroy},
  {"reset", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_7reset, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_6reset},
  {"create", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_9create, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_8create},
  {"setType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_11setType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_10setType},
  {"getType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_13getType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_12getType},
  {"setOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_15setOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_14setOptionsPrefix},
  {"getOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_17getOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_16getOptionsPrefix},
  {"setFromOptions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_19setFromOptions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_18setFromOptions},
  {"duplicate", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_21duplicate, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_20duplicate},
  {"allocate", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_23allocate, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_22allocate},
  {"getLeadingDimension", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_25getLeadingDimension, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_24getLeadingDimension},
  {"setState", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_27setState, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_26setState},
  {"getState", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_29getState, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_28getState},
  {"setParallel", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_31setParallel, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_30setParallel},
  {"getParallel", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_33getParallel, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_32getParallel},
  {"setDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_35setDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_34setDimensions},
  {"getDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_37getDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_36getDimensions},
  {"setBlockSize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_39setBlockSize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_38setBlockSize},
  {"getBlockSize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_41getBlockSize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_40getBlockSize},
  {"setMethod", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_43setMethod, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_42setMethod},
  {"getMethod", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_45getMethod, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_44getMethod},
  {"setCompact", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_47setCompact, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_46setCompact},
  {"getCompact", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_49getCompact, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_48getCompact},
  {"setExtraRow", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_51setExtraRow, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_50setExtraRow},
  {"getExtraRow", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_53getExtraRow, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_52getExtraRow},
  {"setRefined", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_55setRefined, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_54setRefined},
  {"getRefined", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_57getRefined, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_56getRefined},
  {"truncate", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_59truncate, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_58truncate},
  {"updateExtraRow", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_61updateExtraRow, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_60updateExtraRow},
  {"getMat", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_63getMat, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_62getMat},
  {"restoreMat", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_65restoreMat, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_64restoreMat},
  {"setIdentity", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_67setIdentity, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_66setIdentity},
  {"cond", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_69cond, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_68cond},
  {"setSVDDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_71setSVDDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_70setSVDDimensions},
  {"getSVDDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_73getSVDDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_72getSVDDimensions},
  {"setGSVDDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_75setGSVDDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_74setGSVDDimensions},
  {"getGSVDDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_77getGSVDDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_76getGSVDDimensions},
  {"setPEPDegree", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_79setPEPDegree, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_78setPEPDegree},
  {"getPEPDegree", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_81getPEPDegree, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_80getPEPDegree},
  {"setPEPCoefficients", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_83setPEPCoefficients, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_82setPEPCoefficients},
  {"getPEPCoefficients", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2DS_85getPEPCoefficients, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2DS_84getPEPCoefficients},
  {0, 0, 0, 0}
};

static struct PyGetSetDef __pyx_getsets_8slepc4py_5SLEPc_DS[] = {
  {(char *)"state", __pyx_getprop_8slepc4py_5SLEPc_2DS_state, __pyx_setprop_8slepc4py_5SLEPc_2DS_state, (char *)0, 0},
  {(char *)"parallel", __pyx_getprop_8slepc4py_5SLEPc_2DS_parallel, __pyx_setprop_8slepc4py_5SLEPc_2DS_parallel, (char *)0, 0},
  {(char *)"block_size", __pyx_getprop_8slepc4py_5SLEPc_2DS_block_size, __pyx_setprop_8slepc4py_5SLEPc_2DS_block_size, (char *)0, 0},
  {(char *)"method", __pyx_getprop_8slepc4py_5SLEPc_2DS_method, __pyx_setprop_8slepc4py_5SLEPc_2DS_method, (char *)0, 0},
  {(char *)"compact", __pyx_getprop_8slepc4py_5SLEPc_2DS_compact, __pyx_setprop_8slepc4py_5SLEPc_2DS_compact, (char *)0, 0},
  {(char *)"extra_row", __pyx_getprop_8slepc4py_5SLEPc_2DS_extra_row, __pyx_setprop_8slepc4py_5SLEPc_2DS_extra_row, (char *)0, 0},
  {(char *)"refined", __pyx_getprop_8slepc4py_5SLEPc_2DS_refined, __pyx_setprop_8slepc4py_5SLEPc_2DS_refined, (char *)0, 0},
  {0, 0, 0, 0, 0}
};

DL_EXPORT(PyTypeObject) PySlepcDS_Type = {
  PyVarObject_HEAD_INIT(0, 0)
  "slepc4py.SLEPc.DS", /*tp_name*/
  sizeof(struct PySlepcDSObject), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_8slepc4py_5SLEPc_DS, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  #if PY_MAJOR_VERSION < 3
  0, /*tp_compare*/
  #endif
  #if PY_MAJOR_VERSION >= 3
  0, /*tp_as_async*/
  #endif
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
  "\n    DS\n    ", /*tp_doc*/
  __pyx_tp_traverse_8slepc4py_5SLEPc_DS, /*tp_traverse*/
  __pyx_tp_clear_8slepc4py_5SLEPc_DS, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_8slepc4py_5SLEPc_DS, /*tp_methods*/
  0, /*tp_members*/
  __pyx_getsets_8slepc4py_5SLEPc_DS, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  0, /*tp_dictoffset*/
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_8slepc4py_5SLEPc_DS, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if PY_VERSION_HEX >= 0x030400a1
  0, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
  0, /*tp_print*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
  0, /*tp_pypy_flags*/
  #endif
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_FN __pyx_vtable_8slepc4py_5SLEPc_FN;

static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_FN(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct PySlepcFNObject *p;
  PyObject *o = __pyx_ptype_8petsc4py_5PETSc_Object->tp_new(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct PySlepcFNObject *)o);
  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Object*)__pyx_vtabptr_8slepc4py_5SLEPc_FN;
  if (unlikely(__pyx_pw_8slepc4py_5SLEPc_2FN_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_8slepc4py_5SLEPc_FN(PyObject *o) {
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
    if (PyObject_CallFinalizerFromDealloc(o)) return;
  }
  #endif
  PyObject_GC_UnTrack(o);
  PyObject_GC_Track(o);
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) __pyx_ptype_8petsc4py_5PETSc_Object->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_8slepc4py_5SLEPc_FN);
}

static int __pyx_tp_traverse_8slepc4py_5SLEPc_FN(PyObject *o, visitproc v, void *a) {
  int e;
  e = ((likely(__pyx_ptype_8petsc4py_5PETSc_Object)) ? ((__pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse) ? __pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_8slepc4py_5SLEPc_FN)); if (e) return e;
  return 0;
}

static int __pyx_tp_clear_8slepc4py_5SLEPc_FN(PyObject *o) {
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) { if (__pyx_ptype_8petsc4py_5PETSc_Object->tp_clear) __pyx_ptype_8petsc4py_5PETSc_Object->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_8slepc4py_5SLEPc_FN);
  return 0;
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2FN_method(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2FN_6method_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2FN_method(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2FN_6method_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2FN_parallel(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2FN_8parallel_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2FN_parallel(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2FN_8parallel_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyMethodDef __pyx_methods_8slepc4py_5SLEPc_FN[] = {
  {"view", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_3view, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_2view},
  {"destroy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_5destroy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_4destroy},
  {"create", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_7create, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_6create},
  {"setType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_9setType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_8setType},
  {"getType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_11getType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_10getType},
  {"setOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_13setOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_12setOptionsPrefix},
  {"getOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_15getOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_14getOptionsPrefix},
  {"setFromOptions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_17setFromOptions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_16setFromOptions},
  {"duplicate", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_19duplicate, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_18duplicate},
  {"evaluateFunction", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_21evaluateFunction, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_20evaluateFunction},
  {"evaluateDerivative", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_23evaluateDerivative, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_22evaluateDerivative},
  {"evaluateFunctionMat", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_25evaluateFunctionMat, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_24evaluateFunctionMat},
  {"evaluateFunctionMatVec", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_27evaluateFunctionMatVec, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_26evaluateFunctionMatVec},
  {"setScale", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_29setScale, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_28setScale},
  {"getScale", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_31getScale, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_30getScale},
  {"setMethod", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_33setMethod, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_32setMethod},
  {"getMethod", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_35getMethod, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_34getMethod},
  {"setParallel", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_37setParallel, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_36setParallel},
  {"getParallel", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_39getParallel, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_38getParallel},
  {"setRationalNumerator", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_41setRationalNumerator, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_40setRationalNumerator},
  {"getRationalNumerator", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_43getRationalNumerator, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_42getRationalNumerator},
  {"setRationalDenominator", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_45setRationalDenominator, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_44setRationalDenominator},
  {"getRationalDenominator", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_47getRationalDenominator, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_46getRationalDenominator},
  {"setCombineChildren", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_49setCombineChildren, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_48setCombineChildren},
  {"getCombineChildren", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_51getCombineChildren, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_50getCombineChildren},
  {"setPhiIndex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_53setPhiIndex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_52setPhiIndex},
  {"getPhiIndex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2FN_55getPhiIndex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2FN_54getPhiIndex},
  {0, 0, 0, 0}
};

static struct PyGetSetDef __pyx_getsets_8slepc4py_5SLEPc_FN[] = {
  {(char *)"method", __pyx_getprop_8slepc4py_5SLEPc_2FN_method, __pyx_setprop_8slepc4py_5SLEPc_2FN_method, (char *)0, 0},
  {(char *)"parallel", __pyx_getprop_8slepc4py_5SLEPc_2FN_parallel, __pyx_setprop_8slepc4py_5SLEPc_2FN_parallel, (char *)0, 0},
  {0, 0, 0, 0, 0}
};

DL_EXPORT(PyTypeObject) PySlepcFN_Type = {
  PyVarObject_HEAD_INIT(0, 0)
  "slepc4py.SLEPc.FN", /*tp_name*/
  sizeof(struct PySlepcFNObject), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_8slepc4py_5SLEPc_FN, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  #if PY_MAJOR_VERSION < 3
  0, /*tp_compare*/
  #endif
  #if PY_MAJOR_VERSION >= 3
  0, /*tp_as_async*/
  #endif
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
  "\n    FN\n    ", /*tp_doc*/
  __pyx_tp_traverse_8slepc4py_5SLEPc_FN, /*tp_traverse*/
  __pyx_tp_clear_8slepc4py_5SLEPc_FN, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_8slepc4py_5SLEPc_FN, /*tp_methods*/
  0, /*tp_members*/
  __pyx_getsets_8slepc4py_5SLEPc_FN, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  0, /*tp_dictoffset*/
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_8slepc4py_5SLEPc_FN, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if PY_VERSION_HEX >= 0x030400a1
  0, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
  0, /*tp_print*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
  0, /*tp_pypy_flags*/
  #endif
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_RG __pyx_vtable_8slepc4py_5SLEPc_RG;

static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_RG(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct PySlepcRGObject *p;
  PyObject *o = __pyx_ptype_8petsc4py_5PETSc_Object->tp_new(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct PySlepcRGObject *)o);
  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Object*)__pyx_vtabptr_8slepc4py_5SLEPc_RG;
  if (unlikely(__pyx_pw_8slepc4py_5SLEPc_2RG_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_8slepc4py_5SLEPc_RG(PyObject *o) {
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
    if (PyObject_CallFinalizerFromDealloc(o)) return;
  }
  #endif
  PyObject_GC_UnTrack(o);
  PyObject_GC_Track(o);
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) __pyx_ptype_8petsc4py_5PETSc_Object->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_8slepc4py_5SLEPc_RG);
}

static int __pyx_tp_traverse_8slepc4py_5SLEPc_RG(PyObject *o, visitproc v, void *a) {
  int e;
  e = ((likely(__pyx_ptype_8petsc4py_5PETSc_Object)) ? ((__pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse) ? __pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_8slepc4py_5SLEPc_RG)); if (e) return e;
  return 0;
}

static int __pyx_tp_clear_8slepc4py_5SLEPc_RG(PyObject *o) {
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) { if (__pyx_ptype_8petsc4py_5PETSc_Object->tp_clear) __pyx_ptype_8petsc4py_5PETSc_Object->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_8slepc4py_5SLEPc_RG);
  return 0;
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2RG_complement(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2RG_10complement_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2RG_complement(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2RG_10complement_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_2RG_scale(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_2RG_5scale_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_2RG_scale(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_2RG_5scale_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyMethodDef __pyx_methods_8slepc4py_5SLEPc_RG[] = {
  {"view", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_3view, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_2view},
  {"destroy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_5destroy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_4destroy},
  {"create", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_7create, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_6create},
  {"setType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_9setType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_8setType},
  {"getType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_11getType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_10getType},
  {"setOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_13setOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_12setOptionsPrefix},
  {"getOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_15getOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_14getOptionsPrefix},
  {"setFromOptions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_17setFromOptions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_16setFromOptions},
  {"isTrivial", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_19isTrivial, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_18isTrivial},
  {"isAxisymmetric", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_21isAxisymmetric, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_20isAxisymmetric},
  {"getComplement", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_23getComplement, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_22getComplement},
  {"setComplement", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_25setComplement, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_24setComplement},
  {"setScale", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_27setScale, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_26setScale},
  {"getScale", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_29getScale, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_28getScale},
  {"checkInside", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_31checkInside, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_30checkInside},
  {"computeContour", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_33computeContour, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_32computeContour},
  {"computeBoundingBox", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_35computeBoundingBox, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_34computeBoundingBox},
  {"canUseConjugates", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_37canUseConjugates, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_36canUseConjugates},
  {"computeQuadrature", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_39computeQuadrature, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_38computeQuadrature},
  {"setEllipseParameters", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_41setEllipseParameters, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_40setEllipseParameters},
  {"getEllipseParameters", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_43getEllipseParameters, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_42getEllipseParameters},
  {"setIntervalEndpoints", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_45setIntervalEndpoints, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_44setIntervalEndpoints},
  {"getIntervalEndpoints", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_47getIntervalEndpoints, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_46getIntervalEndpoints},
  {"setPolygonVertices", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_49setPolygonVertices, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_48setPolygonVertices},
  {"getPolygonVertices", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_51getPolygonVertices, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_50getPolygonVertices},
  {"setRingParameters", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_53setRingParameters, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_52setRingParameters},
  {"getRingParameters", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_2RG_55getRingParameters, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_2RG_54getRingParameters},
  {0, 0, 0, 0}
};

static struct PyGetSetDef __pyx_getsets_8slepc4py_5SLEPc_RG[] = {
  {(char *)"complement", __pyx_getprop_8slepc4py_5SLEPc_2RG_complement, __pyx_setprop_8slepc4py_5SLEPc_2RG_complement, (char *)0, 0},
  {(char *)"scale", __pyx_getprop_8slepc4py_5SLEPc_2RG_scale, __pyx_setprop_8slepc4py_5SLEPc_2RG_scale, (char *)0, 0},
  {0, 0, 0, 0, 0}
};

DL_EXPORT(PyTypeObject) PySlepcRG_Type = {
  PyVarObject_HEAD_INIT(0, 0)
  "slepc4py.SLEPc.RG", /*tp_name*/
  sizeof(struct PySlepcRGObject), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_8slepc4py_5SLEPc_RG, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  #if PY_MAJOR_VERSION < 3
  0, /*tp_compare*/
  #endif
  #if PY_MAJOR_VERSION >= 3
  0, /*tp_as_async*/
  #endif
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
  "\n    RG\n    ", /*tp_doc*/
  __pyx_tp_traverse_8slepc4py_5SLEPc_RG, /*tp_traverse*/
  __pyx_tp_clear_8slepc4py_5SLEPc_RG, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_8slepc4py_5SLEPc_RG, /*tp_methods*/
  0, /*tp_members*/
  __pyx_getsets_8slepc4py_5SLEPc_RG, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  0, /*tp_dictoffset*/
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_8slepc4py_5SLEPc_RG, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if PY_VERSION_HEX >= 0x030400a1
  0, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
  0, /*tp_print*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
  0, /*tp_pypy_flags*/
  #endif
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_EPS __pyx_vtable_8slepc4py_5SLEPc_EPS;

static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_EPS(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct PySlepcEPSObject *p;
  PyObject *o = __pyx_ptype_8petsc4py_5PETSc_Object->tp_new(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct PySlepcEPSObject *)o);
  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Object*)__pyx_vtabptr_8slepc4py_5SLEPc_EPS;
  if (unlikely(__pyx_pw_8slepc4py_5SLEPc_3EPS_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_8slepc4py_5SLEPc_EPS(PyObject *o) {
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
    if (PyObject_CallFinalizerFromDealloc(o)) return;
  }
  #endif
  PyObject_GC_UnTrack(o);
  PyObject_GC_Track(o);
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) __pyx_ptype_8petsc4py_5PETSc_Object->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_8slepc4py_5SLEPc_EPS);
}

static int __pyx_tp_traverse_8slepc4py_5SLEPc_EPS(PyObject *o, visitproc v, void *a) {
  int e;
  e = ((likely(__pyx_ptype_8petsc4py_5PETSc_Object)) ? ((__pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse) ? __pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_8slepc4py_5SLEPc_EPS)); if (e) return e;
  return 0;
}

static int __pyx_tp_clear_8slepc4py_5SLEPc_EPS(PyObject *o) {
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) { if (__pyx_ptype_8petsc4py_5PETSc_Object->tp_clear) __pyx_ptype_8petsc4py_5PETSc_Object->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_8slepc4py_5SLEPc_EPS);
  return 0;
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3EPS_problem_type(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3EPS_12problem_type_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3EPS_problem_type(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3EPS_12problem_type_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3EPS_extraction(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3EPS_10extraction_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3EPS_extraction(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3EPS_10extraction_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3EPS_which(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3EPS_5which_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3EPS_which(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3EPS_5which_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3EPS_target(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3EPS_6target_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3EPS_target(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3EPS_6target_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3EPS_tol(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3EPS_3tol_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3EPS_tol(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3EPS_3tol_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3EPS_max_it(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3EPS_6max_it_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3EPS_max_it(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3EPS_6max_it_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3EPS_two_sided(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3EPS_9two_sided_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3EPS_two_sided(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3EPS_9two_sided_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3EPS_true_residual(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3EPS_13true_residual_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3EPS_true_residual(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3EPS_13true_residual_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3EPS_purify(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3EPS_6purify_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3EPS_purify(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3EPS_6purify_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3EPS_track_all(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3EPS_9track_all_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3EPS_track_all(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3EPS_9track_all_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3EPS_st(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3EPS_2st_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3EPS_st(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3EPS_2st_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3EPS_bv(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3EPS_2bv_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3EPS_bv(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3EPS_2bv_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3EPS_rg(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3EPS_2rg_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3EPS_rg(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3EPS_2rg_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3EPS_ds(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3EPS_2ds_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3EPS_ds(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3EPS_2ds_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyMethodDef __pyx_methods_8slepc4py_5SLEPc_EPS[] = {
  {"view", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_3view, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_2view},
  {"destroy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_5destroy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_4destroy},
  {"reset", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_7reset, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_6reset},
  {"create", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_9create, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_8create},
  {"setType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_11setType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_10setType},
  {"getType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_13getType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_12getType},
  {"getOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_15getOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_14getOptionsPrefix},
  {"setOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_17setOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_16setOptionsPrefix},
  {"appendOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_19appendOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_18appendOptionsPrefix},
  {"setFromOptions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_21setFromOptions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_20setFromOptions},
  {"getProblemType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_23getProblemType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_22getProblemType},
  {"setProblemType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_25setProblemType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_24setProblemType},
  {"isGeneralized", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_27isGeneralized, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_26isGeneralized},
  {"isHermitian", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_29isHermitian, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_28isHermitian},
  {"isPositive", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_31isPositive, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_30isPositive},
  {"getBalance", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_33getBalance, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_32getBalance},
  {"setBalance", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_35setBalance, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_34setBalance},
  {"getExtraction", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_37getExtraction, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_36getExtraction},
  {"setExtraction", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_39setExtraction, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_38setExtraction},
  {"getWhichEigenpairs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_41getWhichEigenpairs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_40getWhichEigenpairs},
  {"setWhichEigenpairs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_43setWhichEigenpairs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_42setWhichEigenpairs},
  {"getTarget", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_45getTarget, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_44getTarget},
  {"setTarget", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_47setTarget, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_46setTarget},
  {"getInterval", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_49getInterval, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_48getInterval},
  {"setInterval", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_51setInterval, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_50setInterval},
  {"getTolerances", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_53getTolerances, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_52getTolerances},
  {"setTolerances", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_55setTolerances, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_54setTolerances},
  {"getTwoSided", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_57getTwoSided, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_56getTwoSided},
  {"setTwoSided", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_59setTwoSided, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_58setTwoSided},
  {"getPurify", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_61getPurify, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_60getPurify},
  {"setPurify", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_63setPurify, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_62setPurify},
  {"getConvergenceTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_65getConvergenceTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_64getConvergenceTest},
  {"setConvergenceTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_67setConvergenceTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_66setConvergenceTest},
  {"getTrueResidual", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_69getTrueResidual, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_68getTrueResidual},
  {"setTrueResidual", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_71setTrueResidual, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_70setTrueResidual},
  {"getTrackAll", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_73getTrackAll, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_72getTrackAll},
  {"setTrackAll", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_75setTrackAll, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_74setTrackAll},
  {"getDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_77getDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_76getDimensions},
  {"setDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_79setDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_78setDimensions},
  {"getST", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_81getST, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_80getST},
  {"setST", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_83setST, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_82setST},
  {"getBV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_85getBV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_84getBV},
  {"setBV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_87setBV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_86setBV},
  {"getDS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_89getDS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_88getDS},
  {"setDS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_91setDS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_90setDS},
  {"getRG", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_93getRG, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_92getRG},
  {"setRG", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_95setRG, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_94setRG},
  {"getOperators", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_97getOperators, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_96getOperators},
  {"setOperators", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_99setOperators, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_98setOperators},
  {"setDeflationSpace", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_101setDeflationSpace, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_100setDeflationSpace},
  {"setInitialSpace", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_103setInitialSpace, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_102setInitialSpace},
  {"setLeftInitialSpace", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_105setLeftInitialSpace, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_104setLeftInitialSpace},
  {"setStoppingTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_107setStoppingTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_106setStoppingTest},
  {"getStoppingTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_109getStoppingTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_108getStoppingTest},
  {"setArbitrarySelection", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_111setArbitrarySelection, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_110setArbitrarySelection},
  {"setEigenvalueComparison", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_113setEigenvalueComparison, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_112setEigenvalueComparison},
  {"setMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_115setMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_114setMonitor},
  {"getMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_117getMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_116getMonitor},
  {"cancelMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_119cancelMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_118cancelMonitor},
  {"setUp", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_121setUp, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_120setUp},
  {"solve", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_123solve, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_122solve},
  {"getIterationNumber", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_125getIterationNumber, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_124getIterationNumber},
  {"getConvergedReason", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_127getConvergedReason, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_126getConvergedReason},
  {"getConverged", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_129getConverged, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_128getConverged},
  {"getEigenvalue", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_131getEigenvalue, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_130getEigenvalue},
  {"getEigenvector", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_133getEigenvector, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_132getEigenvector},
  {"getLeftEigenvector", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_135getLeftEigenvector, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_134getLeftEigenvector},
  {"getEigenpair", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_137getEigenpair, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_136getEigenpair},
  {"getInvariantSubspace", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_139getInvariantSubspace, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_138getInvariantSubspace},
  {"getErrorEstimate", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_141getErrorEstimate, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_140getErrorEstimate},
  {"computeError", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_143computeError, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_142computeError},
  {"errorView", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_145errorView, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_144errorView},
  {"valuesView", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_147valuesView, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_146valuesView},
  {"vectorsView", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_149vectorsView, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_148vectorsView},
  {"setPowerShiftType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_151setPowerShiftType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_150setPowerShiftType},
  {"getPowerShiftType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_153getPowerShiftType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_152getPowerShiftType},
  {"setArnoldiDelayed", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_155setArnoldiDelayed, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_154setArnoldiDelayed},
  {"getArnoldiDelayed", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_157getArnoldiDelayed, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_156getArnoldiDelayed},
  {"setLanczosReorthogType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_159setLanczosReorthogType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_158setLanczosReorthogType},
  {"getLanczosReorthogType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_161getLanczosReorthogType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_160getLanczosReorthogType},
  {"setKrylovSchurRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_163setKrylovSchurRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_162setKrylovSchurRestart},
  {"getKrylovSchurRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_165getKrylovSchurRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_164getKrylovSchurRestart},
  {"setKrylovSchurLocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_167setKrylovSchurLocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_166setKrylovSchurLocking},
  {"getKrylovSchurLocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_169getKrylovSchurLocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_168getKrylovSchurLocking},
  {"setKrylovSchurPartitions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_171setKrylovSchurPartitions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_170setKrylovSchurPartitions},
  {"getKrylovSchurPartitions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_173getKrylovSchurPartitions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_172getKrylovSchurPartitions},
  {"setKrylovSchurDetectZeros", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_175setKrylovSchurDetectZeros, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_174setKrylovSchurDetectZeros},
  {"getKrylovSchurDetectZeros", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_177getKrylovSchurDetectZeros, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_176getKrylovSchurDetectZeros},
  {"setKrylovSchurDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_179setKrylovSchurDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_178setKrylovSchurDimensions},
  {"getKrylovSchurDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_181getKrylovSchurDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_180getKrylovSchurDimensions},
  {"getKrylovSchurSubcommInfo", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_183getKrylovSchurSubcommInfo, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_182getKrylovSchurSubcommInfo},
  {"getKrylovSchurSubcommPairs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_185getKrylovSchurSubcommPairs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_184getKrylovSchurSubcommPairs},
  {"getKrylovSchurSubcommMats", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_187getKrylovSchurSubcommMats, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_186getKrylovSchurSubcommMats},
  {"updateKrylovSchurSubcommMats", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_189updateKrylovSchurSubcommMats, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_188updateKrylovSchurSubcommMats},
  {"setKrylovSchurSubintervals", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_191setKrylovSchurSubintervals, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_190setKrylovSchurSubintervals},
  {"getKrylovSchurSubintervals", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_193getKrylovSchurSubintervals, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_192getKrylovSchurSubintervals},
  {"getKrylovSchurInertias", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_195getKrylovSchurInertias, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_194getKrylovSchurInertias},
  {"getKrylovSchurKSP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_197getKrylovSchurKSP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_196getKrylovSchurKSP},
  {"setGDKrylovStart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_199setGDKrylovStart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_198setGDKrylovStart},
  {"getGDKrylovStart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_201getGDKrylovStart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_200getGDKrylovStart},
  {"setGDBlockSize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_203setGDBlockSize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_202setGDBlockSize},
  {"getGDBlockSize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_205getGDBlockSize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_204getGDBlockSize},
  {"setGDRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_207setGDRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_206setGDRestart},
  {"getGDRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_209getGDRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_208getGDRestart},
  {"setGDInitialSize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_211setGDInitialSize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_210setGDInitialSize},
  {"getGDInitialSize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_213getGDInitialSize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_212getGDInitialSize},
  {"setGDBOrth", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_215setGDBOrth, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_214setGDBOrth},
  {"getGDBOrth", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_217getGDBOrth, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_216getGDBOrth},
  {"setGDDoubleExpansion", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_219setGDDoubleExpansion, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_218setGDDoubleExpansion},
  {"getGDDoubleExpansion", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_221getGDDoubleExpansion, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_220getGDDoubleExpansion},
  {"setJDKrylovStart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_223setJDKrylovStart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_222setJDKrylovStart},
  {"getJDKrylovStart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_225getJDKrylovStart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_224getJDKrylovStart},
  {"setJDBlockSize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_227setJDBlockSize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_226setJDBlockSize},
  {"getJDBlockSize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_229getJDBlockSize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_228getJDBlockSize},
  {"setJDRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_231setJDRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_230setJDRestart},
  {"getJDRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_233getJDRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_232getJDRestart},
  {"setJDInitialSize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_235setJDInitialSize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_234setJDInitialSize},
  {"getJDInitialSize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_237getJDInitialSize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_236getJDInitialSize},
  {"setJDFix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_239setJDFix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_238setJDFix},
  {"getJDFix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_241getJDFix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_240getJDFix},
  {"setJDConstCorrectionTol", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_243setJDConstCorrectionTol, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_242setJDConstCorrectionTol},
  {"getJDConstCorrectionTol", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_245getJDConstCorrectionTol, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_244getJDConstCorrectionTol},
  {"setJDBOrth", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_247setJDBOrth, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_246setJDBOrth},
  {"getJDBOrth", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_249getJDBOrth, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_248getJDBOrth},
  {"setRQCGReset", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_251setRQCGReset, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_250setRQCGReset},
  {"getRQCGReset", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_253getRQCGReset, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_252getRQCGReset},
  {"setLOBPCGBlockSize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_255setLOBPCGBlockSize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_254setLOBPCGBlockSize},
  {"getLOBPCGBlockSize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_257getLOBPCGBlockSize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_256getLOBPCGBlockSize},
  {"setLOBPCGRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_259setLOBPCGRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_258setLOBPCGRestart},
  {"getLOBPCGRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_261getLOBPCGRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_260getLOBPCGRestart},
  {"setLOBPCGLocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_263setLOBPCGLocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_262setLOBPCGLocking},
  {"getLOBPCGLocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_265getLOBPCGLocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_264getLOBPCGLocking},
  {"setLyapIIRanks", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_267setLyapIIRanks, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_266setLyapIIRanks},
  {"getLyapIIRanks", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_269getLyapIIRanks, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_268getLyapIIRanks},
  {"setCISSExtraction", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_271setCISSExtraction, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_270setCISSExtraction},
  {"getCISSExtraction", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_273getCISSExtraction, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_272getCISSExtraction},
  {"setCISSQuadRule", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_275setCISSQuadRule, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_274setCISSQuadRule},
  {"getCISSQuadRule", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_277getCISSQuadRule, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_276getCISSQuadRule},
  {"setCISSSizes", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_279setCISSSizes, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_278setCISSSizes},
  {"getCISSSizes", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_281getCISSSizes, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_280getCISSSizes},
  {"setCISSThreshold", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_283setCISSThreshold, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_282setCISSThreshold},
  {"getCISSThreshold", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_285getCISSThreshold, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_284getCISSThreshold},
  {"setCISSRefinement", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_287setCISSRefinement, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_286setCISSRefinement},
  {"getCISSRefinement", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_289getCISSRefinement, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_288getCISSRefinement},
  {"setCISSUseST", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_291setCISSUseST, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_290setCISSUseST},
  {"getCISSUseST", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_293getCISSUseST, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_292getCISSUseST},
  {"getCISSKSPs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3EPS_295getCISSKSPs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3EPS_294getCISSKSPs},
  {0, 0, 0, 0}
};

static struct PyGetSetDef __pyx_getsets_8slepc4py_5SLEPc_EPS[] = {
  {(char *)"problem_type", __pyx_getprop_8slepc4py_5SLEPc_3EPS_problem_type, __pyx_setprop_8slepc4py_5SLEPc_3EPS_problem_type, (char *)0, 0},
  {(char *)"extraction", __pyx_getprop_8slepc4py_5SLEPc_3EPS_extraction, __pyx_setprop_8slepc4py_5SLEPc_3EPS_extraction, (char *)0, 0},
  {(char *)"which", __pyx_getprop_8slepc4py_5SLEPc_3EPS_which, __pyx_setprop_8slepc4py_5SLEPc_3EPS_which, (char *)0, 0},
  {(char *)"target", __pyx_getprop_8slepc4py_5SLEPc_3EPS_target, __pyx_setprop_8slepc4py_5SLEPc_3EPS_target, (char *)0, 0},
  {(char *)"tol", __pyx_getprop_8slepc4py_5SLEPc_3EPS_tol, __pyx_setprop_8slepc4py_5SLEPc_3EPS_tol, (char *)0, 0},
  {(char *)"max_it", __pyx_getprop_8slepc4py_5SLEPc_3EPS_max_it, __pyx_setprop_8slepc4py_5SLEPc_3EPS_max_it, (char *)0, 0},
  {(char *)"two_sided", __pyx_getprop_8slepc4py_5SLEPc_3EPS_two_sided, __pyx_setprop_8slepc4py_5SLEPc_3EPS_two_sided, (char *)0, 0},
  {(char *)"true_residual", __pyx_getprop_8slepc4py_5SLEPc_3EPS_true_residual, __pyx_setprop_8slepc4py_5SLEPc_3EPS_true_residual, (char *)0, 0},
  {(char *)"purify", __pyx_getprop_8slepc4py_5SLEPc_3EPS_purify, __pyx_setprop_8slepc4py_5SLEPc_3EPS_purify, (char *)0, 0},
  {(char *)"track_all", __pyx_getprop_8slepc4py_5SLEPc_3EPS_track_all, __pyx_setprop_8slepc4py_5SLEPc_3EPS_track_all, (char *)0, 0},
  {(char *)"st", __pyx_getprop_8slepc4py_5SLEPc_3EPS_st, __pyx_setprop_8slepc4py_5SLEPc_3EPS_st, (char *)0, 0},
  {(char *)"bv", __pyx_getprop_8slepc4py_5SLEPc_3EPS_bv, __pyx_setprop_8slepc4py_5SLEPc_3EPS_bv, (char *)0, 0},
  {(char *)"rg", __pyx_getprop_8slepc4py_5SLEPc_3EPS_rg, __pyx_setprop_8slepc4py_5SLEPc_3EPS_rg, (char *)0, 0},
  {(char *)"ds", __pyx_getprop_8slepc4py_5SLEPc_3EPS_ds, __pyx_setprop_8slepc4py_5SLEPc_3EPS_ds, (char *)0, 0},
  {0, 0, 0, 0, 0}
};

DL_EXPORT(PyTypeObject) PySlepcEPS_Type = {
  PyVarObject_HEAD_INIT(0, 0)
  "slepc4py.SLEPc.EPS", /*tp_name*/
  sizeof(struct PySlepcEPSObject), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_8slepc4py_5SLEPc_EPS, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  #if PY_MAJOR_VERSION < 3
  0, /*tp_compare*/
  #endif
  #if PY_MAJOR_VERSION >= 3
  0, /*tp_as_async*/
  #endif
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
  "\n    EPS\n    ", /*tp_doc*/
  __pyx_tp_traverse_8slepc4py_5SLEPc_EPS, /*tp_traverse*/
  __pyx_tp_clear_8slepc4py_5SLEPc_EPS, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_8slepc4py_5SLEPc_EPS, /*tp_methods*/
  0, /*tp_members*/
  __pyx_getsets_8slepc4py_5SLEPc_EPS, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  0, /*tp_dictoffset*/
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_8slepc4py_5SLEPc_EPS, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if PY_VERSION_HEX >= 0x030400a1
  0, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
  0, /*tp_print*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
  0, /*tp_pypy_flags*/
  #endif
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_SVD __pyx_vtable_8slepc4py_5SLEPc_SVD;

static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_SVD(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct PySlepcSVDObject *p;
  PyObject *o = __pyx_ptype_8petsc4py_5PETSc_Object->tp_new(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct PySlepcSVDObject *)o);
  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Object*)__pyx_vtabptr_8slepc4py_5SLEPc_SVD;
  if (unlikely(__pyx_pw_8slepc4py_5SLEPc_3SVD_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_8slepc4py_5SLEPc_SVD(PyObject *o) {
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
    if (PyObject_CallFinalizerFromDealloc(o)) return;
  }
  #endif
  PyObject_GC_UnTrack(o);
  PyObject_GC_Track(o);
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) __pyx_ptype_8petsc4py_5PETSc_Object->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_8slepc4py_5SLEPc_SVD);
}

static int __pyx_tp_traverse_8slepc4py_5SLEPc_SVD(PyObject *o, visitproc v, void *a) {
  int e;
  e = ((likely(__pyx_ptype_8petsc4py_5PETSc_Object)) ? ((__pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse) ? __pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_8slepc4py_5SLEPc_SVD)); if (e) return e;
  return 0;
}

static int __pyx_tp_clear_8slepc4py_5SLEPc_SVD(PyObject *o) {
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) { if (__pyx_ptype_8petsc4py_5PETSc_Object->tp_clear) __pyx_ptype_8petsc4py_5PETSc_Object->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_8slepc4py_5SLEPc_SVD);
  return 0;
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3SVD_problem_type(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3SVD_12problem_type_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3SVD_problem_type(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3SVD_12problem_type_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3SVD_transpose_mode(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3SVD_14transpose_mode_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3SVD_transpose_mode(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3SVD_14transpose_mode_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3SVD_which(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3SVD_5which_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3SVD_which(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3SVD_5which_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3SVD_tol(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3SVD_3tol_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3SVD_tol(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3SVD_3tol_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3SVD_max_it(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3SVD_6max_it_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3SVD_max_it(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3SVD_6max_it_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3SVD_track_all(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3SVD_9track_all_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3SVD_track_all(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3SVD_9track_all_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3SVD_ds(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3SVD_2ds_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3SVD_ds(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3SVD_2ds_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyMethodDef __pyx_methods_8slepc4py_5SLEPc_SVD[] = {
  {"view", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_3view, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_2view},
  {"destroy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_5destroy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_4destroy},
  {"reset", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_7reset, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_6reset},
  {"create", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_9create, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_8create},
  {"setType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_11setType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_10setType},
  {"getType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_13getType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_12getType},
  {"getOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_15getOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_14getOptionsPrefix},
  {"setOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_17setOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_16setOptionsPrefix},
  {"appendOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_19appendOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_18appendOptionsPrefix},
  {"setFromOptions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_21setFromOptions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_20setFromOptions},
  {"getProblemType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_23getProblemType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_22getProblemType},
  {"setProblemType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_25setProblemType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_24setProblemType},
  {"isGeneralized", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_27isGeneralized, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_26isGeneralized},
  {"isHyperbolic", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_29isHyperbolic, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_28isHyperbolic},
  {"getImplicitTranspose", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_31getImplicitTranspose, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_30getImplicitTranspose},
  {"setImplicitTranspose", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_33setImplicitTranspose, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_32setImplicitTranspose},
  {"getWhichSingularTriplets", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_35getWhichSingularTriplets, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_34getWhichSingularTriplets},
  {"setWhichSingularTriplets", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_37setWhichSingularTriplets, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_36setWhichSingularTriplets},
  {"getTolerances", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_39getTolerances, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_38getTolerances},
  {"setTolerances", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_41setTolerances, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_40setTolerances},
  {"getConvergenceTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_43getConvergenceTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_42getConvergenceTest},
  {"setConvergenceTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_45setConvergenceTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_44setConvergenceTest},
  {"getTrackAll", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_47getTrackAll, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_46getTrackAll},
  {"setTrackAll", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_49setTrackAll, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_48setTrackAll},
  {"getDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_51getDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_50getDimensions},
  {"setDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_53setDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_52setDimensions},
  {"getBV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_55getBV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_54getBV},
  {"setBV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_57setBV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_56setBV},
  {"getDS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_59getDS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_58getDS},
  {"setDS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_61setDS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_60setDS},
  {"getOperators", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_63getOperators, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_62getOperators},
  {"setOperators", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_65setOperators, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_64setOperators},
  {"getSignature", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_67getSignature, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_66getSignature},
  {"setSignature", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_69setSignature, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_68setSignature},
  {"setInitialSpaces", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_71setInitialSpaces, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_70setInitialSpaces},
  {"setStoppingTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_73setStoppingTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_72setStoppingTest},
  {"getStoppingTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_75getStoppingTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_74getStoppingTest},
  {"setMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_77setMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_76setMonitor},
  {"getMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_79getMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_78getMonitor},
  {"cancelMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_81cancelMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_80cancelMonitor},
  {"setUp", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_83setUp, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_82setUp},
  {"solve", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_85solve, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_84solve},
  {"getIterationNumber", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_87getIterationNumber, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_86getIterationNumber},
  {"getConvergedReason", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_89getConvergedReason, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_88getConvergedReason},
  {"getConverged", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_91getConverged, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_90getConverged},
  {"getValue", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_93getValue, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_92getValue},
  {"getVectors", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_95getVectors, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_94getVectors},
  {"getSingularTriplet", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_97getSingularTriplet, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_96getSingularTriplet},
  {"computeError", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_99computeError, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_98computeError},
  {"errorView", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_101errorView, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_100errorView},
  {"valuesView", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_103valuesView, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_102valuesView},
  {"vectorsView", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_105vectorsView, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_104vectorsView},
  {"setCrossEPS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_107setCrossEPS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_106setCrossEPS},
  {"getCrossEPS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_109getCrossEPS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_108getCrossEPS},
  {"setCrossExplicitMatrix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_111setCrossExplicitMatrix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_110setCrossExplicitMatrix},
  {"getCrossExplicitMatrix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_113getCrossExplicitMatrix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_112getCrossExplicitMatrix},
  {"setCyclicEPS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_115setCyclicEPS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_114setCyclicEPS},
  {"getCyclicEPS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_117getCyclicEPS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_116getCyclicEPS},
  {"setCyclicExplicitMatrix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_119setCyclicExplicitMatrix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_118setCyclicExplicitMatrix},
  {"getCyclicExplicitMatrix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_121getCyclicExplicitMatrix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_120getCyclicExplicitMatrix},
  {"setLanczosOneSide", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_123setLanczosOneSide, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_122setLanczosOneSide},
  {"getLanczosOneSide", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_125getLanczosOneSide, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_124getLanczosOneSide},
  {"setTRLanczosOneSide", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_127setTRLanczosOneSide, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_126setTRLanczosOneSide},
  {"getTRLanczosOneSide", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_129getTRLanczosOneSide, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_128getTRLanczosOneSide},
  {"setTRLanczosGBidiag", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_131setTRLanczosGBidiag, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_130setTRLanczosGBidiag},
  {"getTRLanczosGBidiag", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_133getTRLanczosGBidiag, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_132getTRLanczosGBidiag},
  {"setTRLanczosRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_135setTRLanczosRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_134setTRLanczosRestart},
  {"getTRLanczosRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_137getTRLanczosRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_136getTRLanczosRestart},
  {"setTRLanczosLocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_139setTRLanczosLocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_138setTRLanczosLocking},
  {"getTRLanczosLocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_141getTRLanczosLocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_140getTRLanczosLocking},
  {"setTRLanczosKSP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_143setTRLanczosKSP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_142setTRLanczosKSP},
  {"getTRLanczosKSP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_145getTRLanczosKSP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_144getTRLanczosKSP},
  {"setTRLanczosExplicitMatrix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_147setTRLanczosExplicitMatrix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_146setTRLanczosExplicitMatrix},
  {"getTRLanczosExplicitMatrix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3SVD_149getTRLanczosExplicitMatrix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3SVD_148getTRLanczosExplicitMatrix},
  {0, 0, 0, 0}
};

static struct PyGetSetDef __pyx_getsets_8slepc4py_5SLEPc_SVD[] = {
  {(char *)"problem_type", __pyx_getprop_8slepc4py_5SLEPc_3SVD_problem_type, __pyx_setprop_8slepc4py_5SLEPc_3SVD_problem_type, (char *)0, 0},
  {(char *)"transpose_mode", __pyx_getprop_8slepc4py_5SLEPc_3SVD_transpose_mode, __pyx_setprop_8slepc4py_5SLEPc_3SVD_transpose_mode, (char *)0, 0},
  {(char *)"which", __pyx_getprop_8slepc4py_5SLEPc_3SVD_which, __pyx_setprop_8slepc4py_5SLEPc_3SVD_which, (char *)0, 0},
  {(char *)"tol", __pyx_getprop_8slepc4py_5SLEPc_3SVD_tol, __pyx_setprop_8slepc4py_5SLEPc_3SVD_tol, (char *)0, 0},
  {(char *)"max_it", __pyx_getprop_8slepc4py_5SLEPc_3SVD_max_it, __pyx_setprop_8slepc4py_5SLEPc_3SVD_max_it, (char *)0, 0},
  {(char *)"track_all", __pyx_getprop_8slepc4py_5SLEPc_3SVD_track_all, __pyx_setprop_8slepc4py_5SLEPc_3SVD_track_all, (char *)0, 0},
  {(char *)"ds", __pyx_getprop_8slepc4py_5SLEPc_3SVD_ds, __pyx_setprop_8slepc4py_5SLEPc_3SVD_ds, (char *)0, 0},
  {0, 0, 0, 0, 0}
};

DL_EXPORT(PyTypeObject) PySlepcSVD_Type = {
  PyVarObject_HEAD_INIT(0, 0)
  "slepc4py.SLEPc.SVD", /*tp_name*/
  sizeof(struct PySlepcSVDObject), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_8slepc4py_5SLEPc_SVD, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  #if PY_MAJOR_VERSION < 3
  0, /*tp_compare*/
  #endif
  #if PY_MAJOR_VERSION >= 3
  0, /*tp_as_async*/
  #endif
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
  "\n    SVD\n    ", /*tp_doc*/
  __pyx_tp_traverse_8slepc4py_5SLEPc_SVD, /*tp_traverse*/
  __pyx_tp_clear_8slepc4py_5SLEPc_SVD, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_8slepc4py_5SLEPc_SVD, /*tp_methods*/
  0, /*tp_members*/
  __pyx_getsets_8slepc4py_5SLEPc_SVD, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  0, /*tp_dictoffset*/
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_8slepc4py_5SLEPc_SVD, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if PY_VERSION_HEX >= 0x030400a1
  0, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
  0, /*tp_print*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
  0, /*tp_pypy_flags*/
  #endif
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_PEP __pyx_vtable_8slepc4py_5SLEPc_PEP;

static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_PEP(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct PySlepcPEPObject *p;
  PyObject *o = __pyx_ptype_8petsc4py_5PETSc_Object->tp_new(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct PySlepcPEPObject *)o);
  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Object*)__pyx_vtabptr_8slepc4py_5SLEPc_PEP;
  if (unlikely(__pyx_pw_8slepc4py_5SLEPc_3PEP_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_8slepc4py_5SLEPc_PEP(PyObject *o) {
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
    if (PyObject_CallFinalizerFromDealloc(o)) return;
  }
  #endif
  PyObject_GC_UnTrack(o);
  PyObject_GC_Track(o);
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) __pyx_ptype_8petsc4py_5PETSc_Object->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_8slepc4py_5SLEPc_PEP);
}

static int __pyx_tp_traverse_8slepc4py_5SLEPc_PEP(PyObject *o, visitproc v, void *a) {
  int e;
  e = ((likely(__pyx_ptype_8petsc4py_5PETSc_Object)) ? ((__pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse) ? __pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_8slepc4py_5SLEPc_PEP)); if (e) return e;
  return 0;
}

static int __pyx_tp_clear_8slepc4py_5SLEPc_PEP(PyObject *o) {
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) { if (__pyx_ptype_8petsc4py_5PETSc_Object->tp_clear) __pyx_ptype_8petsc4py_5PETSc_Object->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_8slepc4py_5SLEPc_PEP);
  return 0;
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3PEP_problem_type(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3PEP_12problem_type_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3PEP_problem_type(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3PEP_12problem_type_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3PEP_which(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3PEP_5which_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3PEP_which(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3PEP_5which_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3PEP_target(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3PEP_6target_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3PEP_target(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3PEP_6target_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3PEP_extract(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3PEP_7extract_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3PEP_extract(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3PEP_7extract_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3PEP_tol(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3PEP_3tol_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3PEP_tol(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3PEP_3tol_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3PEP_max_it(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3PEP_6max_it_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3PEP_max_it(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3PEP_6max_it_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3PEP_track_all(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3PEP_9track_all_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3PEP_track_all(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3PEP_9track_all_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3PEP_st(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3PEP_2st_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3PEP_st(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3PEP_2st_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3PEP_bv(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3PEP_2bv_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3PEP_bv(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3PEP_2bv_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3PEP_rg(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3PEP_2rg_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3PEP_rg(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3PEP_2rg_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3PEP_ds(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3PEP_2ds_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3PEP_ds(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3PEP_2ds_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyMethodDef __pyx_methods_8slepc4py_5SLEPc_PEP[] = {
  {"view", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_3view, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_2view},
  {"destroy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_5destroy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_4destroy},
  {"reset", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_7reset, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_6reset},
  {"create", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_9create, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_8create},
  {"setType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_11setType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_10setType},
  {"getType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_13getType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_12getType},
  {"getOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_15getOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_14getOptionsPrefix},
  {"setOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_17setOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_16setOptionsPrefix},
  {"appendOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_19appendOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_18appendOptionsPrefix},
  {"setFromOptions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_21setFromOptions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_20setFromOptions},
  {"getBasis", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_23getBasis, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_22getBasis},
  {"setBasis", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_25setBasis, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_24setBasis},
  {"getProblemType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_27getProblemType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_26getProblemType},
  {"setProblemType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_29setProblemType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_28setProblemType},
  {"getWhichEigenpairs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_31getWhichEigenpairs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_30getWhichEigenpairs},
  {"setWhichEigenpairs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_33setWhichEigenpairs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_32setWhichEigenpairs},
  {"getTarget", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_35getTarget, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_34getTarget},
  {"setTarget", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_37setTarget, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_36setTarget},
  {"getTolerances", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_39getTolerances, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_38getTolerances},
  {"setTolerances", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_41setTolerances, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_40setTolerances},
  {"getInterval", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_43getInterval, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_42getInterval},
  {"setInterval", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_45setInterval, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_44setInterval},
  {"getConvergenceTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_47getConvergenceTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_46getConvergenceTest},
  {"setConvergenceTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_49setConvergenceTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_48setConvergenceTest},
  {"getRefine", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_51getRefine, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_50getRefine},
  {"setRefine", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_53setRefine, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_52setRefine},
  {"getRefineKSP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_55getRefineKSP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_54getRefineKSP},
  {"setExtract", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_57setExtract, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_56setExtract},
  {"getExtract", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_59getExtract, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_58getExtract},
  {"getTrackAll", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_61getTrackAll, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_60getTrackAll},
  {"setTrackAll", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_63setTrackAll, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_62setTrackAll},
  {"getDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_65getDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_64getDimensions},
  {"setDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_67setDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_66setDimensions},
  {"getST", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_69getST, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_68getST},
  {"setST", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_71setST, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_70setST},
  {"getScale", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_73getScale, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_72getScale},
  {"setScale", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_75setScale, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_74setScale},
  {"getBV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_77getBV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_76getBV},
  {"setBV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_79setBV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_78setBV},
  {"getRG", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_81getRG, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_80getRG},
  {"setRG", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_83setRG, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_82setRG},
  {"getDS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_85getDS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_84getDS},
  {"setDS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_87setDS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_86setDS},
  {"getOperators", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_89getOperators, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_88getOperators},
  {"setOperators", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_91setOperators, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_90setOperators},
  {"setInitialSpace", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_93setInitialSpace, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_92setInitialSpace},
  {"setStoppingTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_95setStoppingTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_94setStoppingTest},
  {"getStoppingTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_97getStoppingTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_96getStoppingTest},
  {"setMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_99setMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_98setMonitor},
  {"getMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_101getMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_100getMonitor},
  {"cancelMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_103cancelMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_102cancelMonitor},
  {"setUp", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_105setUp, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_104setUp},
  {"solve", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_107solve, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_106solve},
  {"getIterationNumber", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_109getIterationNumber, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_108getIterationNumber},
  {"getConvergedReason", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_111getConvergedReason, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_110getConvergedReason},
  {"getConverged", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_113getConverged, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_112getConverged},
  {"getEigenpair", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_115getEigenpair, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_114getEigenpair},
  {"getErrorEstimate", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_117getErrorEstimate, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_116getErrorEstimate},
  {"computeError", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_119computeError, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_118computeError},
  {"errorView", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_121errorView, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_120errorView},
  {"valuesView", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_123valuesView, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_122valuesView},
  {"vectorsView", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_125vectorsView, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_124vectorsView},
  {"setLinearEPS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_127setLinearEPS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_126setLinearEPS},
  {"getLinearEPS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_129getLinearEPS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_128getLinearEPS},
  {"setLinearLinearization", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_131setLinearLinearization, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_130setLinearLinearization},
  {"getLinearLinearization", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_133getLinearLinearization, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_132getLinearLinearization},
  {"setLinearExplicitMatrix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_135setLinearExplicitMatrix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_134setLinearExplicitMatrix},
  {"getLinearExplicitMatrix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_137getLinearExplicitMatrix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_136getLinearExplicitMatrix},
  {"setQArnoldiRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_139setQArnoldiRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_138setQArnoldiRestart},
  {"getQArnoldiRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_141getQArnoldiRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_140getQArnoldiRestart},
  {"setQArnoldiLocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_143setQArnoldiLocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_142setQArnoldiLocking},
  {"getQArnoldiLocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_145getQArnoldiLocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_144getQArnoldiLocking},
  {"setTOARRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_147setTOARRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_146setTOARRestart},
  {"getTOARRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_149getTOARRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_148getTOARRestart},
  {"setTOARLocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_151setTOARLocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_150setTOARLocking},
  {"getTOARLocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_153getTOARLocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_152getTOARLocking},
  {"setSTOARLinearization", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_155setSTOARLinearization, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_154setSTOARLinearization},
  {"getSTOARLinearization", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_157getSTOARLinearization, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_156getSTOARLinearization},
  {"setSTOARLocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_159setSTOARLocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_158setSTOARLocking},
  {"getSTOARLocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_161getSTOARLocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_160getSTOARLocking},
  {"setSTOARDetectZeros", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_163setSTOARDetectZeros, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_162setSTOARDetectZeros},
  {"getSTOARDetectZeros", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_165getSTOARDetectZeros, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_164getSTOARDetectZeros},
  {"setSTOARDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_167setSTOARDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_166setSTOARDimensions},
  {"getSTOARDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_169getSTOARDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_168getSTOARDimensions},
  {"getSTOARInertias", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_171getSTOARInertias, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_170getSTOARInertias},
  {"setSTOARCheckEigenvalueType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_173setSTOARCheckEigenvalueType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_172setSTOARCheckEigenvalueType},
  {"getSTOARCheckEigenvalueType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_175getSTOARCheckEigenvalueType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_174getSTOARCheckEigenvalueType},
  {"setJDRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_177setJDRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_176setJDRestart},
  {"getJDRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_179getJDRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_178getJDRestart},
  {"setJDFix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_181setJDFix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_180setJDFix},
  {"getJDFix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_183getJDFix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_182getJDFix},
  {"setJDReusePreconditioner", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_185setJDReusePreconditioner, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_184setJDReusePreconditioner},
  {"getJDReusePreconditioner", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_187getJDReusePreconditioner, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_186getJDReusePreconditioner},
  {"setJDMinimalityIndex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_189setJDMinimalityIndex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_188setJDMinimalityIndex},
  {"getJDMinimalityIndex", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_191getJDMinimalityIndex, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_190getJDMinimalityIndex},
  {"setJDProjection", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_193setJDProjection, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_192setJDProjection},
  {"getJDProjection", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_195getJDProjection, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_194getJDProjection},
  {"setCISSExtraction", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_197setCISSExtraction, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_196setCISSExtraction},
  {"getCISSExtraction", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_199getCISSExtraction, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_198getCISSExtraction},
  {"setCISSSizes", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_201setCISSSizes, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_200setCISSSizes},
  {"getCISSSizes", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_203getCISSSizes, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_202getCISSSizes},
  {"setCISSThreshold", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_205setCISSThreshold, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_204setCISSThreshold},
  {"getCISSThreshold", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_207getCISSThreshold, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_206getCISSThreshold},
  {"setCISSRefinement", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_209setCISSRefinement, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_208setCISSRefinement},
  {"getCISSRefinement", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_211getCISSRefinement, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_210getCISSRefinement},
  {"getCISSKSPs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3PEP_213getCISSKSPs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3PEP_212getCISSKSPs},
  {0, 0, 0, 0}
};

static struct PyGetSetDef __pyx_getsets_8slepc4py_5SLEPc_PEP[] = {
  {(char *)"problem_type", __pyx_getprop_8slepc4py_5SLEPc_3PEP_problem_type, __pyx_setprop_8slepc4py_5SLEPc_3PEP_problem_type, (char *)0, 0},
  {(char *)"which", __pyx_getprop_8slepc4py_5SLEPc_3PEP_which, __pyx_setprop_8slepc4py_5SLEPc_3PEP_which, (char *)0, 0},
  {(char *)"target", __pyx_getprop_8slepc4py_5SLEPc_3PEP_target, __pyx_setprop_8slepc4py_5SLEPc_3PEP_target, (char *)0, 0},
  {(char *)"extract", __pyx_getprop_8slepc4py_5SLEPc_3PEP_extract, __pyx_setprop_8slepc4py_5SLEPc_3PEP_extract, (char *)0, 0},
  {(char *)"tol", __pyx_getprop_8slepc4py_5SLEPc_3PEP_tol, __pyx_setprop_8slepc4py_5SLEPc_3PEP_tol, (char *)0, 0},
  {(char *)"max_it", __pyx_getprop_8slepc4py_5SLEPc_3PEP_max_it, __pyx_setprop_8slepc4py_5SLEPc_3PEP_max_it, (char *)0, 0},
  {(char *)"track_all", __pyx_getprop_8slepc4py_5SLEPc_3PEP_track_all, __pyx_setprop_8slepc4py_5SLEPc_3PEP_track_all, (char *)0, 0},
  {(char *)"st", __pyx_getprop_8slepc4py_5SLEPc_3PEP_st, __pyx_setprop_8slepc4py_5SLEPc_3PEP_st, (char *)0, 0},
  {(char *)"bv", __pyx_getprop_8slepc4py_5SLEPc_3PEP_bv, __pyx_setprop_8slepc4py_5SLEPc_3PEP_bv, (char *)0, 0},
  {(char *)"rg", __pyx_getprop_8slepc4py_5SLEPc_3PEP_rg, __pyx_setprop_8slepc4py_5SLEPc_3PEP_rg, (char *)0, 0},
  {(char *)"ds", __pyx_getprop_8slepc4py_5SLEPc_3PEP_ds, __pyx_setprop_8slepc4py_5SLEPc_3PEP_ds, (char *)0, 0},
  {0, 0, 0, 0, 0}
};

DL_EXPORT(PyTypeObject) PySlepcPEP_Type = {
  PyVarObject_HEAD_INIT(0, 0)
  "slepc4py.SLEPc.PEP", /*tp_name*/
  sizeof(struct PySlepcPEPObject), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_8slepc4py_5SLEPc_PEP, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  #if PY_MAJOR_VERSION < 3
  0, /*tp_compare*/
  #endif
  #if PY_MAJOR_VERSION >= 3
  0, /*tp_as_async*/
  #endif
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
  "\n    PEP\n    ", /*tp_doc*/
  __pyx_tp_traverse_8slepc4py_5SLEPc_PEP, /*tp_traverse*/
  __pyx_tp_clear_8slepc4py_5SLEPc_PEP, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_8slepc4py_5SLEPc_PEP, /*tp_methods*/
  0, /*tp_members*/
  __pyx_getsets_8slepc4py_5SLEPc_PEP, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  0, /*tp_dictoffset*/
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_8slepc4py_5SLEPc_PEP, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if PY_VERSION_HEX >= 0x030400a1
  0, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
  0, /*tp_print*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
  0, /*tp_pypy_flags*/
  #endif
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_NEP __pyx_vtable_8slepc4py_5SLEPc_NEP;

static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_NEP(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct PySlepcNEPObject *p;
  PyObject *o = __pyx_ptype_8petsc4py_5PETSc_Object->tp_new(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct PySlepcNEPObject *)o);
  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Object*)__pyx_vtabptr_8slepc4py_5SLEPc_NEP;
  if (unlikely(__pyx_pw_8slepc4py_5SLEPc_3NEP_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_8slepc4py_5SLEPc_NEP(PyObject *o) {
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
    if (PyObject_CallFinalizerFromDealloc(o)) return;
  }
  #endif
  PyObject_GC_UnTrack(o);
  PyObject_GC_Track(o);
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) __pyx_ptype_8petsc4py_5PETSc_Object->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_8slepc4py_5SLEPc_NEP);
}

static int __pyx_tp_traverse_8slepc4py_5SLEPc_NEP(PyObject *o, visitproc v, void *a) {
  int e;
  e = ((likely(__pyx_ptype_8petsc4py_5PETSc_Object)) ? ((__pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse) ? __pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_8slepc4py_5SLEPc_NEP)); if (e) return e;
  return 0;
}

static int __pyx_tp_clear_8slepc4py_5SLEPc_NEP(PyObject *o) {
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) { if (__pyx_ptype_8petsc4py_5PETSc_Object->tp_clear) __pyx_ptype_8petsc4py_5PETSc_Object->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_8slepc4py_5SLEPc_NEP);
  return 0;
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3NEP_problem_type(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3NEP_12problem_type_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3NEP_problem_type(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3NEP_12problem_type_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3NEP_which(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3NEP_5which_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3NEP_which(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3NEP_5which_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3NEP_target(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3NEP_6target_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3NEP_target(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3NEP_6target_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3NEP_tol(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3NEP_3tol_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3NEP_tol(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3NEP_3tol_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3NEP_max_it(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3NEP_6max_it_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3NEP_max_it(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3NEP_6max_it_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3NEP_track_all(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3NEP_9track_all_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3NEP_track_all(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3NEP_9track_all_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3NEP_bv(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3NEP_2bv_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3NEP_bv(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3NEP_2bv_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3NEP_rg(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3NEP_2rg_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3NEP_rg(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3NEP_2rg_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3NEP_ds(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3NEP_2ds_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3NEP_ds(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3NEP_2ds_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyMethodDef __pyx_methods_8slepc4py_5SLEPc_NEP[] = {
  {"view", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_3view, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_2view},
  {"destroy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_5destroy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_4destroy},
  {"reset", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_7reset, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_6reset},
  {"create", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_9create, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_8create},
  {"setType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_11setType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_10setType},
  {"getType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_13getType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_12getType},
  {"getOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_15getOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_14getOptionsPrefix},
  {"setOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_17setOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_16setOptionsPrefix},
  {"appendOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_19appendOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_18appendOptionsPrefix},
  {"setFromOptions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_21setFromOptions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_20setFromOptions},
  {"getProblemType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_23getProblemType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_22getProblemType},
  {"setProblemType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_25setProblemType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_24setProblemType},
  {"getWhichEigenpairs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_27getWhichEigenpairs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_26getWhichEigenpairs},
  {"setWhichEigenpairs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_29setWhichEigenpairs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_28setWhichEigenpairs},
  {"getTarget", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_31getTarget, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_30getTarget},
  {"setTarget", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_33setTarget, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_32setTarget},
  {"getTolerances", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_35getTolerances, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_34getTolerances},
  {"setTolerances", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_37setTolerances, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_36setTolerances},
  {"getConvergenceTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_39getConvergenceTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_38getConvergenceTest},
  {"setConvergenceTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_41setConvergenceTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_40setConvergenceTest},
  {"getRefine", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_43getRefine, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_42getRefine},
  {"setRefine", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_45setRefine, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_44setRefine},
  {"getRefineKSP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_47getRefineKSP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_46getRefineKSP},
  {"getTrackAll", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_49getTrackAll, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_48getTrackAll},
  {"setTrackAll", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_51setTrackAll, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_50setTrackAll},
  {"getDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_53getDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_52getDimensions},
  {"setDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_55setDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_54setDimensions},
  {"getBV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_57getBV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_56getBV},
  {"setBV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_59setBV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_58setBV},
  {"getRG", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_61getRG, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_60getRG},
  {"setRG", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_63setRG, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_62setRG},
  {"getDS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_65getDS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_64getDS},
  {"setDS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_67setDS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_66setDS},
  {"setInitialSpace", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_69setInitialSpace, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_68setInitialSpace},
  {"setStoppingTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_71setStoppingTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_70setStoppingTest},
  {"getStoppingTest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_73getStoppingTest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_72getStoppingTest},
  {"setMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_75setMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_74setMonitor},
  {"getMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_77getMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_76getMonitor},
  {"cancelMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_79cancelMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_78cancelMonitor},
  {"setUp", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_81setUp, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_80setUp},
  {"solve", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_83solve, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_82solve},
  {"getIterationNumber", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_85getIterationNumber, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_84getIterationNumber},
  {"getConvergedReason", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_87getConvergedReason, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_86getConvergedReason},
  {"getConverged", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_89getConverged, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_88getConverged},
  {"getEigenpair", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_91getEigenpair, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_90getEigenpair},
  {"getLeftEigenvector", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_93getLeftEigenvector, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_92getLeftEigenvector},
  {"getErrorEstimate", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_95getErrorEstimate, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_94getErrorEstimate},
  {"computeError", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_97computeError, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_96computeError},
  {"errorView", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_99errorView, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_98errorView},
  {"valuesView", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_101valuesView, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_100valuesView},
  {"vectorsView", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_103vectorsView, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_102vectorsView},
  {"setFunction", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_105setFunction, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_104setFunction},
  {"getFunction", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_107getFunction, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_106getFunction},
  {"setJacobian", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_109setJacobian, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_108setJacobian},
  {"getJacobian", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_111getJacobian, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_110getJacobian},
  {"setSplitOperator", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_113setSplitOperator, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_112setSplitOperator},
  {"getSplitOperator", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_115getSplitOperator, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_114getSplitOperator},
  {"setSplitPreconditioner", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_117setSplitPreconditioner, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_116setSplitPreconditioner},
  {"getSplitPreconditioner", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_119getSplitPreconditioner, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_118getSplitPreconditioner},
  {"getTwoSided", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_121getTwoSided, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_120getTwoSided},
  {"setTwoSided", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_123setTwoSided, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_122setTwoSided},
  {"applyResolvent", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_125applyResolvent, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_124applyResolvent},
  {"setRIILagPreconditioner", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_127setRIILagPreconditioner, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_126setRIILagPreconditioner},
  {"getRIILagPreconditioner", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_129getRIILagPreconditioner, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_128getRIILagPreconditioner},
  {"setRIIConstCorrectionTol", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_131setRIIConstCorrectionTol, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_130setRIIConstCorrectionTol},
  {"getRIIConstCorrectionTol", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_133getRIIConstCorrectionTol, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_132getRIIConstCorrectionTol},
  {"setRIIMaximumIterations", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_135setRIIMaximumIterations, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_134setRIIMaximumIterations},
  {"getRIIMaximumIterations", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_137getRIIMaximumIterations, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_136getRIIMaximumIterations},
  {"setRIIHermitian", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_139setRIIHermitian, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_138setRIIHermitian},
  {"getRIIHermitian", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_141getRIIHermitian, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_140getRIIHermitian},
  {"setRIIDeflationThreshold", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_143setRIIDeflationThreshold, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_142setRIIDeflationThreshold},
  {"getRIIDeflationThreshold", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_145getRIIDeflationThreshold, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_144getRIIDeflationThreshold},
  {"setRIIKSP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_147setRIIKSP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_146setRIIKSP},
  {"getRIIKSP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_149getRIIKSP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_148getRIIKSP},
  {"setSLPDeflationThreshold", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_151setSLPDeflationThreshold, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_150setSLPDeflationThreshold},
  {"getSLPDeflationThreshold", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_153getSLPDeflationThreshold, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_152getSLPDeflationThreshold},
  {"setSLPEPS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_155setSLPEPS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_154setSLPEPS},
  {"getSLPEPS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_157getSLPEPS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_156getSLPEPS},
  {"setSLPEPSLeft", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_159setSLPEPSLeft, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_158setSLPEPSLeft},
  {"getSLPEPSLeft", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_161getSLPEPSLeft, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_160getSLPEPSLeft},
  {"setSLPKSP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_163setSLPKSP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_162setSLPKSP},
  {"getSLPKSP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_165getSLPKSP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_164getSLPKSP},
  {"setNArnoldiKSP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_167setNArnoldiKSP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_166setNArnoldiKSP},
  {"getNArnoldiKSP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_169getNArnoldiKSP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_168getNArnoldiKSP},
  {"setNArnoldiLagPreconditioner", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_171setNArnoldiLagPreconditioner, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_170setNArnoldiLagPreconditioner},
  {"getNArnoldiLagPreconditioner", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_173getNArnoldiLagPreconditioner, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_172getNArnoldiLagPreconditioner},
  {"setInterpolPEP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_175setInterpolPEP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_174setInterpolPEP},
  {"getInterpolPEP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_177getInterpolPEP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_176getInterpolPEP},
  {"setInterpolInterpolation", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_179setInterpolInterpolation, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_178setInterpolInterpolation},
  {"getInterpolInterpolation", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_181getInterpolInterpolation, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_180getInterpolInterpolation},
  {"setNLEIGSRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_183setNLEIGSRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_182setNLEIGSRestart},
  {"getNLEIGSRestart", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_185getNLEIGSRestart, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_184getNLEIGSRestart},
  {"setNLEIGSLocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_187setNLEIGSLocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_186setNLEIGSLocking},
  {"getNLEIGSLocking", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_189getNLEIGSLocking, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_188getNLEIGSLocking},
  {"setNLEIGSInterpolation", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_191setNLEIGSInterpolation, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_190setNLEIGSInterpolation},
  {"getNLEIGSInterpolation", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_193getNLEIGSInterpolation, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_192getNLEIGSInterpolation},
  {"setNLEIGSFullBasis", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_195setNLEIGSFullBasis, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_194setNLEIGSFullBasis},
  {"getNLEIGSFullBasis", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_197getNLEIGSFullBasis, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_196getNLEIGSFullBasis},
  {"setNLEIGSEPS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_199setNLEIGSEPS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_198setNLEIGSEPS},
  {"getNLEIGSEPS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_201getNLEIGSEPS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_200getNLEIGSEPS},
  {"setNLEIGSRKShifts", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_203setNLEIGSRKShifts, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_202setNLEIGSRKShifts},
  {"getNLEIGSRKShifts", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_205getNLEIGSRKShifts, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_204getNLEIGSRKShifts},
  {"getNLEIGSKSPs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_207getNLEIGSKSPs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_206getNLEIGSKSPs},
  {"setCISSExtraction", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_209setCISSExtraction, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_208setCISSExtraction},
  {"getCISSExtraction", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_211getCISSExtraction, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_210getCISSExtraction},
  {"setCISSSizes", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_213setCISSSizes, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_212setCISSSizes},
  {"getCISSSizes", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_215getCISSSizes, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_214getCISSSizes},
  {"setCISSThreshold", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_217setCISSThreshold, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_216setCISSThreshold},
  {"getCISSThreshold", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_219getCISSThreshold, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_218getCISSThreshold},
  {"setCISSRefinement", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_221setCISSRefinement, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_220setCISSRefinement},
  {"getCISSRefinement", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_223getCISSRefinement, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_222getCISSRefinement},
  {"getCISSKSPs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3NEP_225getCISSKSPs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3NEP_224getCISSKSPs},
  {0, 0, 0, 0}
};

static struct PyGetSetDef __pyx_getsets_8slepc4py_5SLEPc_NEP[] = {
  {(char *)"problem_type", __pyx_getprop_8slepc4py_5SLEPc_3NEP_problem_type, __pyx_setprop_8slepc4py_5SLEPc_3NEP_problem_type, (char *)0, 0},
  {(char *)"which", __pyx_getprop_8slepc4py_5SLEPc_3NEP_which, __pyx_setprop_8slepc4py_5SLEPc_3NEP_which, (char *)0, 0},
  {(char *)"target", __pyx_getprop_8slepc4py_5SLEPc_3NEP_target, __pyx_setprop_8slepc4py_5SLEPc_3NEP_target, (char *)0, 0},
  {(char *)"tol", __pyx_getprop_8slepc4py_5SLEPc_3NEP_tol, __pyx_setprop_8slepc4py_5SLEPc_3NEP_tol, (char *)0, 0},
  {(char *)"max_it", __pyx_getprop_8slepc4py_5SLEPc_3NEP_max_it, __pyx_setprop_8slepc4py_5SLEPc_3NEP_max_it, (char *)0, 0},
  {(char *)"track_all", __pyx_getprop_8slepc4py_5SLEPc_3NEP_track_all, __pyx_setprop_8slepc4py_5SLEPc_3NEP_track_all, (char *)0, 0},
  {(char *)"bv", __pyx_getprop_8slepc4py_5SLEPc_3NEP_bv, __pyx_setprop_8slepc4py_5SLEPc_3NEP_bv, (char *)0, 0},
  {(char *)"rg", __pyx_getprop_8slepc4py_5SLEPc_3NEP_rg, __pyx_setprop_8slepc4py_5SLEPc_3NEP_rg, (char *)0, 0},
  {(char *)"ds", __pyx_getprop_8slepc4py_5SLEPc_3NEP_ds, __pyx_setprop_8slepc4py_5SLEPc_3NEP_ds, (char *)0, 0},
  {0, 0, 0, 0, 0}
};

DL_EXPORT(PyTypeObject) PySlepcNEP_Type = {
  PyVarObject_HEAD_INIT(0, 0)
  "slepc4py.SLEPc.NEP", /*tp_name*/
  sizeof(struct PySlepcNEPObject), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_8slepc4py_5SLEPc_NEP, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  #if PY_MAJOR_VERSION < 3
  0, /*tp_compare*/
  #endif
  #if PY_MAJOR_VERSION >= 3
  0, /*tp_as_async*/
  #endif
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
  "\n    NEP\n    ", /*tp_doc*/
  __pyx_tp_traverse_8slepc4py_5SLEPc_NEP, /*tp_traverse*/
  __pyx_tp_clear_8slepc4py_5SLEPc_NEP, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_8slepc4py_5SLEPc_NEP, /*tp_methods*/
  0, /*tp_members*/
  __pyx_getsets_8slepc4py_5SLEPc_NEP, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  0, /*tp_dictoffset*/
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_8slepc4py_5SLEPc_NEP, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if PY_VERSION_HEX >= 0x030400a1
  0, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
  0, /*tp_print*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
  0, /*tp_pypy_flags*/
  #endif
};
static struct __pyx_vtabstruct_8slepc4py_5SLEPc_MFN __pyx_vtable_8slepc4py_5SLEPc_MFN;

static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_MFN(PyTypeObject *t, PyObject *a, PyObject *k) {
  struct PySlepcMFNObject *p;
  PyObject *o = __pyx_ptype_8petsc4py_5PETSc_Object->tp_new(t, a, k);
  if (unlikely(!o)) return 0;
  p = ((struct PySlepcMFNObject *)o);
  p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Object*)__pyx_vtabptr_8slepc4py_5SLEPc_MFN;
  if (unlikely(__pyx_pw_8slepc4py_5SLEPc_3MFN_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_8slepc4py_5SLEPc_MFN(PyObject *o) {
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) {
    if (PyObject_CallFinalizerFromDealloc(o)) return;
  }
  #endif
  PyObject_GC_UnTrack(o);
  PyObject_GC_Track(o);
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) __pyx_ptype_8petsc4py_5PETSc_Object->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_8slepc4py_5SLEPc_MFN);
}

static int __pyx_tp_traverse_8slepc4py_5SLEPc_MFN(PyObject *o, visitproc v, void *a) {
  int e;
  e = ((likely(__pyx_ptype_8petsc4py_5PETSc_Object)) ? ((__pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse) ? __pyx_ptype_8petsc4py_5PETSc_Object->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_8slepc4py_5SLEPc_MFN)); if (e) return e;
  return 0;
}

static int __pyx_tp_clear_8slepc4py_5SLEPc_MFN(PyObject *o) {
  if (likely(__pyx_ptype_8petsc4py_5PETSc_Object)) { if (__pyx_ptype_8petsc4py_5PETSc_Object->tp_clear) __pyx_ptype_8petsc4py_5PETSc_Object->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_8slepc4py_5SLEPc_MFN);
  return 0;
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3MFN_tol(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3MFN_3tol_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3MFN_tol(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3MFN_3tol_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3MFN_max_it(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3MFN_6max_it_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3MFN_max_it(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3MFN_6max_it_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3MFN_fn(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3MFN_2fn_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3MFN_fn(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3MFN_2fn_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyObject *__pyx_getprop_8slepc4py_5SLEPc_3MFN_bv(PyObject *o, CYTHON_UNUSED void *x) {
  return __pyx_pw_8slepc4py_5SLEPc_3MFN_2bv_1__get__(o);
}

static int __pyx_setprop_8slepc4py_5SLEPc_3MFN_bv(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
  if (v) {
    return __pyx_pw_8slepc4py_5SLEPc_3MFN_2bv_3__set__(o, v);
  }
  else {
    PyErr_SetString(PyExc_NotImplementedError, "__del__");
    return -1;
  }
}

static PyMethodDef __pyx_methods_8slepc4py_5SLEPc_MFN[] = {
  {"view", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_3view, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_2view},
  {"destroy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_5destroy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_4destroy},
  {"reset", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_7reset, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_6reset},
  {"create", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_9create, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_8create},
  {"setType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_11setType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_10setType},
  {"getType", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_13getType, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_12getType},
  {"getOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_15getOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_14getOptionsPrefix},
  {"setOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_17setOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_16setOptionsPrefix},
  {"appendOptionsPrefix", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_19appendOptionsPrefix, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_18appendOptionsPrefix},
  {"setFromOptions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_21setFromOptions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_20setFromOptions},
  {"getTolerances", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_23getTolerances, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_22getTolerances},
  {"setTolerances", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_25setTolerances, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_24setTolerances},
  {"getDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_27getDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_26getDimensions},
  {"setDimensions", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_29setDimensions, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_28setDimensions},
  {"getFN", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_31getFN, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_30getFN},
  {"setFN", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_33setFN, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_32setFN},
  {"getBV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_35getBV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_34getBV},
  {"setBV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_37setBV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_36setBV},
  {"getOperator", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_39getOperator, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_38getOperator},
  {"setOperator", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_41setOperator, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_40setOperator},
  {"setMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_43setMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_42setMonitor},
  {"getMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_45getMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_44getMonitor},
  {"cancelMonitor", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_47cancelMonitor, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_46cancelMonitor},
  {"setUp", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_49setUp, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_48setUp},
  {"solve", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_51solve, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_50solve},
  {"solveTranspose", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_53solveTranspose, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_52solveTranspose},
  {"getIterationNumber", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_55getIterationNumber, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_54getIterationNumber},
  {"getConvergedReason", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_57getConvergedReason, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_56getConvergedReason},
  {"setErrorIfNotConverged", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_59setErrorIfNotConverged, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_58setErrorIfNotConverged},
  {"getErrorIfNotConverged", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3MFN_61getErrorIfNotConverged, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3MFN_60getErrorIfNotConverged},
  {0, 0, 0, 0}
};

static struct PyGetSetDef __pyx_getsets_8slepc4py_5SLEPc_MFN[] = {
  {(char *)"tol", __pyx_getprop_8slepc4py_5SLEPc_3MFN_tol, __pyx_setprop_8slepc4py_5SLEPc_3MFN_tol, (char *)0, 0},
  {(char *)"max_it", __pyx_getprop_8slepc4py_5SLEPc_3MFN_max_it, __pyx_setprop_8slepc4py_5SLEPc_3MFN_max_it, (char *)0, 0},
  {(char *)"fn", __pyx_getprop_8slepc4py_5SLEPc_3MFN_fn, __pyx_setprop_8slepc4py_5SLEPc_3MFN_fn, (char *)0, 0},
  {(char *)"bv", __pyx_getprop_8slepc4py_5SLEPc_3MFN_bv, __pyx_setprop_8slepc4py_5SLEPc_3MFN_bv, (char *)0, 0},
  {0, 0, 0, 0, 0}
};

DL_EXPORT(PyTypeObject) PySlepcMFN_Type = {
  PyVarObject_HEAD_INIT(0, 0)
  "slepc4py.SLEPc.MFN", /*tp_name*/
  sizeof(struct PySlepcMFNObject), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_8slepc4py_5SLEPc_MFN, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  #if PY_MAJOR_VERSION < 3
  0, /*tp_compare*/
  #endif
  #if PY_MAJOR_VERSION >= 3
  0, /*tp_as_async*/
  #endif
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
  "\n    MFN\n    ", /*tp_doc*/
  __pyx_tp_traverse_8slepc4py_5SLEPc_MFN, /*tp_traverse*/
  __pyx_tp_clear_8slepc4py_5SLEPc_MFN, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_8slepc4py_5SLEPc_MFN, /*tp_methods*/
  0, /*tp_members*/
  __pyx_getsets_8slepc4py_5SLEPc_MFN, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  0, /*tp_dictoffset*/
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_8slepc4py_5SLEPc_MFN, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if PY_VERSION_HEX >= 0x030400a1
  0, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
  0, /*tp_print*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
  0, /*tp_pypy_flags*/
  #endif
};

static PyObject *__pyx_tp_new_8slepc4py_5SLEPc__p_mem(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
  PyObject *o;
  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
    o = (*t->tp_alloc)(t, 0);
  } else {
    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
  }
  if (unlikely(!o)) return 0;
  if (unlikely(__pyx_pw_8slepc4py_5SLEPc_6_p_mem_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
  return o;
  bad:
  Py_DECREF(o); o = 0;
  return NULL;
}

static void __pyx_tp_dealloc_8slepc4py_5SLEPc__p_mem(PyObject *o) {
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
    if (PyObject_CallFinalizerFromDealloc(o)) return;
  }
  #endif
  {
    PyObject *etype, *eval, *etb;
    PyErr_Fetch(&etype, &eval, &etb);
    __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);
    __pyx_pw_8slepc4py_5SLEPc_6_p_mem_3__dealloc__(o);
    __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);
    PyErr_Restore(etype, eval, etb);
  }
  (*Py_TYPE(o)->tp_free)(o);
}

static PyMethodDef __pyx_methods_8slepc4py_5SLEPc__p_mem[] = {
  {0, 0, 0, 0}
};

static PyTypeObject __pyx_type_8slepc4py_5SLEPc__p_mem = {
  PyVarObject_HEAD_INIT(0, 0)
  "slepc4py.SLEPc._p_mem", /*tp_name*/
  sizeof(struct __pyx_obj_8slepc4py_5SLEPc__p_mem), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_8slepc4py_5SLEPc__p_mem, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  #if PY_MAJOR_VERSION < 3
  0, /*tp_compare*/
  #endif
  #if PY_MAJOR_VERSION >= 3
  0, /*tp_as_async*/
  #endif
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
  0, /*tp_doc*/
  0, /*tp_traverse*/
  0, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_8slepc4py_5SLEPc__p_mem, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  0, /*tp_dictoffset*/
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_8slepc4py_5SLEPc__p_mem, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if PY_VERSION_HEX >= 0x030400a1
  0, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
  0, /*tp_print*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
  0, /*tp_pypy_flags*/
  #endif
};

static PyObject *__pyx_tp_new_8slepc4py_5SLEPc_Sys(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
  PyObject *o;
  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
    o = (*t->tp_alloc)(t, 0);
  } else {
    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
  }
  if (unlikely(!o)) return 0;
  return o;
}

static void __pyx_tp_dealloc_8slepc4py_5SLEPc_Sys(PyObject *o) {
  #if CYTHON_USE_TP_FINALIZE
  if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
    if (PyObject_CallFinalizerFromDealloc(o)) return;
  }
  #endif
  (*Py_TYPE(o)->tp_free)(o);
}

static PyMethodDef __pyx_methods_8slepc4py_5SLEPc_Sys[] = {
  {"getVersion", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3Sys_1getVersion, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3Sys_getVersion},
  {"getVersionInfo", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3Sys_3getVersionInfo, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3Sys_2getVersionInfo},
  {"isInitialized", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3Sys_5isInitialized, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3Sys_4isInitialized},
  {"isFinalized", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3Sys_7isFinalized, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3Sys_6isFinalized},
  {"hasExternalPackage", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8slepc4py_5SLEPc_3Sys_9hasExternalPackage, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8slepc4py_5SLEPc_3Sys_8hasExternalPackage},
  {0, 0, 0, 0}
};

static PyTypeObject __pyx_type_8slepc4py_5SLEPc_Sys = {
  PyVarObject_HEAD_INIT(0, 0)
  "slepc4py.SLEPc.Sys", /*tp_name*/
  sizeof(struct __pyx_obj_8slepc4py_5SLEPc_Sys), /*tp_basicsize*/
  0, /*tp_itemsize*/
  __pyx_tp_dealloc_8slepc4py_5SLEPc_Sys, /*tp_dealloc*/
  #if PY_VERSION_HEX < 0x030800b4
  0, /*tp_print*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4
  0, /*tp_vectorcall_offset*/
  #endif
  0, /*tp_getattr*/
  0, /*tp_setattr*/
  #if PY_MAJOR_VERSION < 3
  0, /*tp_compare*/
  #endif
  #if PY_MAJOR_VERSION >= 3
  0, /*tp_as_async*/
  #endif
  0, /*tp_repr*/
  0, /*tp_as_number*/
  0, /*tp_as_sequence*/
  0, /*tp_as_mapping*/
  0, /*tp_hash*/
  0, /*tp_call*/
  0, /*tp_str*/
  0, /*tp_getattro*/
  0, /*tp_setattro*/
  0, /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
  0, /*tp_doc*/
  0, /*tp_traverse*/
  0, /*tp_clear*/
  0, /*tp_richcompare*/
  0, /*tp_weaklistoffset*/
  0, /*tp_iter*/
  0, /*tp_iternext*/
  __pyx_methods_8slepc4py_5SLEPc_Sys, /*tp_methods*/
  0, /*tp_members*/
  0, /*tp_getset*/
  0, /*tp_base*/
  0, /*tp_dict*/
  0, /*tp_descr_get*/
  0, /*tp_descr_set*/
  0, /*tp_dictoffset*/
  0, /*tp_init*/
  0, /*tp_alloc*/
  __pyx_tp_new_8slepc4py_5SLEPc_Sys, /*tp_new*/
  0, /*tp_free*/
  0, /*tp_is_gc*/
  0, /*tp_bases*/
  0, /*tp_mro*/
  0, /*tp_cache*/
  0, /*tp_subclasses*/
  0, /*tp_weaklist*/
  0, /*tp_del*/
  0, /*tp_version_tag*/
  #if PY_VERSION_HEX >= 0x030400a1
  0, /*tp_finalize*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
  0, /*tp_vectorcall*/
  #endif
  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
  0, /*tp_print*/
  #endif
  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
  0, /*tp_pypy_flags*/
  #endif
};

static PyMethodDef __pyx_methods[] = {
  {0, 0, 0, 0}
};

#if PY_MAJOR_VERSION >= 3
#if CYTHON_PEP489_MULTI_PHASE_INIT
static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
static int __pyx_pymod_exec_SLEPc(PyObject* module); /*proto*/
static PyModuleDef_Slot __pyx_moduledef_slots[] = {
  {Py_mod_create, (void*)__pyx_pymod_create},
  {Py_mod_exec, (void*)__pyx_pymod_exec_SLEPc},
  {0, NULL}
};
#endif

static struct PyModuleDef __pyx_moduledef = {
    PyModuleDef_HEAD_INIT,
    "SLEPc",
    0, /* m_doc */
  #if CYTHON_PEP489_MULTI_PHASE_INIT
    0, /* m_size */
  #else
    -1, /* m_size */
  #endif
    __pyx_methods /* m_methods */,
  #if CYTHON_PEP489_MULTI_PHASE_INIT
    __pyx_moduledef_slots, /* m_slots */
  #else
    NULL, /* m_reload */
  #endif
    NULL, /* m_traverse */
    NULL, /* m_clear */
    (freefunc)__pyx_module_cleanup /* m_free */
};
#endif
#ifndef CYTHON_SMALL_CODE
#if defined(__clang__)
    #define CYTHON_SMALL_CODE
#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
    #define CYTHON_SMALL_CODE __attribute__((cold))
#else
    #define CYTHON_SMALL_CODE
#endif
#endif

static __Pyx_StringTabEntry __pyx_string_tab[] = {
  {&__pyx_n_s_A, __pyx_k_A, sizeof(__pyx_k_A), 0, 0, 1, 1},
  {&__pyx_n_s_ABS, __pyx_k_ABS, sizeof(__pyx_k_ABS), 0, 0, 1, 1},
  {&__pyx_n_s_ABSOLUTE, __pyx_k_ABSOLUTE, sizeof(__pyx_k_ABSOLUTE), 0, 0, 1, 1},
  {&__pyx_n_s_ADD, __pyx_k_ADD, sizeof(__pyx_k_ADD), 0, 0, 1, 1},
  {&__pyx_n_s_ALL, __pyx_k_ALL, sizeof(__pyx_k_ALL), 0, 0, 1, 1},
  {&__pyx_n_s_ALWAYS, __pyx_k_ALWAYS, sizeof(__pyx_k_ALWAYS), 0, 0, 1, 1},
  {&__pyx_n_s_ARNOLDI, __pyx_k_ARNOLDI, sizeof(__pyx_k_ARNOLDI), 0, 0, 1, 1},
  {&__pyx_n_s_ARPACK, __pyx_k_ARPACK, sizeof(__pyx_k_ARPACK), 0, 0, 1, 1},
  {&__pyx_n_s_Au, __pyx_k_Au, sizeof(__pyx_k_Au), 0, 0, 1, 1},
  {&__pyx_n_s_B, __pyx_k_B, sizeof(__pyx_k_B), 0, 0, 1, 1},
  {&__pyx_n_s_BACKWARD, __pyx_k_BACKWARD, sizeof(__pyx_k_BACKWARD), 0, 0, 1, 1},
  {&__pyx_n_s_BASIC, __pyx_k_BASIC, sizeof(__pyx_k_BASIC), 0, 0, 1, 1},
  {&__pyx_n_s_BLOPEX, __pyx_k_BLOPEX, sizeof(__pyx_k_BLOPEX), 0, 0, 1, 1},
  {&__pyx_n_s_BOTH, __pyx_k_BOTH, sizeof(__pyx_k_BOTH), 0, 0, 1, 1},
  {&__pyx_n_s_BV, __pyx_k_BV, sizeof(__pyx_k_BV), 0, 0, 1, 1},
  {&__pyx_n_s_BVMatMultType, __pyx_k_BVMatMultType, sizeof(__pyx_k_BVMatMultType), 0, 0, 1, 1},
  {&__pyx_n_s_BVOrthogBlockType, __pyx_k_BVOrthogBlockType, sizeof(__pyx_k_BVOrthogBlockType), 0, 0, 1, 1},
  {&__pyx_n_s_BVOrthogRefineType, __pyx_k_BVOrthogRefineType, sizeof(__pyx_k_BVOrthogRefineType), 0, 0, 1, 1},
  {&__pyx_n_s_BVOrthogType, __pyx_k_BVOrthogType, sizeof(__pyx_k_BVOrthogType), 0, 0, 1, 1},
  {&__pyx_n_s_BVSVDMethod, __pyx_k_BVSVDMethod, sizeof(__pyx_k_BVSVDMethod), 0, 0, 1, 1},
  {&__pyx_n_s_BVType, __pyx_k_BVType, sizeof(__pyx_k_BVType), 0, 0, 1, 1},
  {&__pyx_kp_s_BV_block_orthogonalization_type, __pyx_k_BV_block_orthogonalization_type, sizeof(__pyx_k_BV_block_orthogonalization_type), 0, 0, 1, 0},
  {&__pyx_kp_s_BV_mat_mult_types_VECS_Perform, __pyx_k_BV_mat_mult_types_VECS_Perform, sizeof(__pyx_k_BV_mat_mult_types_VECS_Perform), 0, 0, 1, 0},
  {&__pyx_kp_s_BV_methods_for_computing_the_SV, __pyx_k_BV_methods_for_computing_the_SV, sizeof(__pyx_k_BV_methods_for_computing_the_SV), 0, 0, 1, 0},
  {&__pyx_kp_s_BV_orthogonalization_refinement, __pyx_k_BV_orthogonalization_refinement, sizeof(__pyx_k_BV_orthogonalization_refinement), 0, 0, 1, 0},
  {&__pyx_kp_s_BV_orthogonalization_types_CGS, __pyx_k_BV_orthogonalization_types_CGS, sizeof(__pyx_k_BV_orthogonalization_types_CGS), 0, 0, 1, 0},
  {&__pyx_kp_s_BV_type, __pyx_k_BV_type, sizeof(__pyx_k_BV_type), 0, 0, 1, 0},
  {&__pyx_n_s_Balance, __pyx_k_Balance, sizeof(__pyx_k_Balance), 0, 0, 1, 1},
  {&__pyx_n_s_Basis, __pyx_k_Basis, sizeof(__pyx_k_Basis), 0, 0, 1, 1},
  {&__pyx_n_s_BlockType, __pyx_k_BlockType, sizeof(__pyx_k_BlockType), 0, 0, 1, 1},
  {&__pyx_n_s_Bu, __pyx_k_Bu, sizeof(__pyx_k_Bu), 0, 0, 1, 1},
  {&__pyx_n_s_C, __pyx_k_C, sizeof(__pyx_k_C), 0, 0, 1, 1},
  {&__pyx_n_s_CAA, __pyx_k_CAA, sizeof(__pyx_k_CAA), 0, 0, 1, 1},
  {&__pyx_n_s_CAYLEY, __pyx_k_CAYLEY, sizeof(__pyx_k_CAYLEY), 0, 0, 1, 1},
  {&__pyx_n_s_CGS, __pyx_k_CGS, sizeof(__pyx_k_CGS), 0, 0, 1, 1},
  {&__pyx_n_s_CHEBYSHEV, __pyx_k_CHEBYSHEV, sizeof(__pyx_k_CHEBYSHEV), 0, 0, 1, 1},
  {&__pyx_n_s_CHEBYSHEV1, __pyx_k_CHEBYSHEV1, sizeof(__pyx_k_CHEBYSHEV1), 0, 0, 1, 1},
  {&__pyx_n_s_CHEBYSHEV2, __pyx_k_CHEBYSHEV2, sizeof(__pyx_k_CHEBYSHEV2), 0, 0, 1, 1},
  {&__pyx_n_s_CHOL, __pyx_k_CHOL, sizeof(__pyx_k_CHOL), 0, 0, 1, 1},
  {&__pyx_n_s_CISS, __pyx_k_CISS, sizeof(__pyx_k_CISS), 0, 0, 1, 1},
  {&__pyx_n_s_CISSExtraction, __pyx_k_CISSExtraction, sizeof(__pyx_k_CISSExtraction), 0, 0, 1, 1},
  {&__pyx_n_s_CISSQuadRule, __pyx_k_CISSQuadRule, sizeof(__pyx_k_CISSQuadRule), 0, 0, 1, 1},
  {&__pyx_n_s_COMBINE, __pyx_k_COMBINE, sizeof(__pyx_k_COMBINE), 0, 0, 1, 1},
  {&__pyx_n_s_COMM_NULL, __pyx_k_COMM_NULL, sizeof(__pyx_k_COMM_NULL), 0, 0, 1, 1},
  {&__pyx_n_s_COMM_SELF, __pyx_k_COMM_SELF, sizeof(__pyx_k_COMM_SELF), 0, 0, 1, 1},
  {&__pyx_n_s_COMM_WORLD, __pyx_k_COMM_WORLD, sizeof(__pyx_k_COMM_WORLD), 0, 0, 1, 1},
  {&__pyx_n_s_COMPOSE, __pyx_k_COMPOSE, sizeof(__pyx_k_COMPOSE), 0, 0, 1, 1},
  {&__pyx_n_s_CONDENSED, __pyx_k_CONDENSED, sizeof(__pyx_k_CONDENSED), 0, 0, 1, 1},
  {&__pyx_n_s_CONSTANT, __pyx_k_CONSTANT, sizeof(__pyx_k_CONSTANT), 0, 0, 1, 1},
  {&__pyx_n_s_CONTIGUOUS, __pyx_k_CONTIGUOUS, sizeof(__pyx_k_CONTIGUOUS), 0, 0, 1, 1},
  {&__pyx_n_s_CONVERGED_ITERATING, __pyx_k_CONVERGED_ITERATING, sizeof(__pyx_k_CONVERGED_ITERATING), 0, 0, 1, 1},
  {&__pyx_n_s_CONVERGED_ITS, __pyx_k_CONVERGED_ITS, sizeof(__pyx_k_CONVERGED_ITS), 0, 0, 1, 1},
  {&__pyx_n_s_CONVERGED_MAXIT, __pyx_k_CONVERGED_MAXIT, sizeof(__pyx_k_CONVERGED_MAXIT), 0, 0, 1, 1},
  {&__pyx_n_s_CONVERGED_TOL, __pyx_k_CONVERGED_TOL, sizeof(__pyx_k_CONVERGED_TOL), 0, 0, 1, 1},
  {&__pyx_n_s_CONVERGED_USER, __pyx_k_CONVERGED_USER, sizeof(__pyx_k_CONVERGED_USER), 0, 0, 1, 1},
  {&__pyx_n_s_COPY, __pyx_k_COPY, sizeof(__pyx_k_COPY), 0, 0, 1, 1},
  {&__pyx_n_s_CROSS, __pyx_k_CROSS, sizeof(__pyx_k_CROSS), 0, 0, 1, 1},
  {&__pyx_n_s_CYCLIC, __pyx_k_CYCLIC, sizeof(__pyx_k_CYCLIC), 0, 0, 1, 1},
  {&__pyx_n_s_CombineType, __pyx_k_CombineType, sizeof(__pyx_k_CombineType), 0, 0, 1, 1},
  {&__pyx_n_s_ComplexType, __pyx_k_ComplexType, sizeof(__pyx_k_ComplexType), 0, 0, 1, 1},
  {&__pyx_n_s_Conv, __pyx_k_Conv, sizeof(__pyx_k_Conv), 0, 0, 1, 1},
  {&__pyx_n_s_ConvergedReason, __pyx_k_ConvergedReason, sizeof(__pyx_k_ConvergedReason), 0, 0, 1, 1},
  {&__pyx_n_s_D, __pyx_k_D, sizeof(__pyx_k_D), 0, 0, 1, 1},
  {&__pyx_n_s_DECIDE, __pyx_k_DECIDE, sizeof(__pyx_k_DECIDE), 0, 0, 1, 1},
  {&__pyx_n_s_DEFAULT, __pyx_k_DEFAULT, sizeof(__pyx_k_DEFAULT), 0, 0, 1, 1},
  {&__pyx_n_s_DELAYED, __pyx_k_DELAYED, sizeof(__pyx_k_DELAYED), 0, 0, 1, 1},
  {&__pyx_n_s_DETERMINE, __pyx_k_DETERMINE, sizeof(__pyx_k_DETERMINE), 0, 0, 1, 1},
  {&__pyx_n_s_DIAGONAL, __pyx_k_DIAGONAL, sizeof(__pyx_k_DIAGONAL), 0, 0, 1, 1},
  {&__pyx_n_s_DISTRIBUTED, __pyx_k_DISTRIBUTED, sizeof(__pyx_k_DISTRIBUTED), 0, 0, 1, 1},
  {&__pyx_n_s_DIVERGED_BREAKDOWN, __pyx_k_DIVERGED_BREAKDOWN, sizeof(__pyx_k_DIVERGED_BREAKDOWN), 0, 0, 1, 1},
  {&__pyx_n_s_DIVERGED_ITS, __pyx_k_DIVERGED_ITS, sizeof(__pyx_k_DIVERGED_ITS), 0, 0, 1, 1},
  {&__pyx_n_s_DIVERGED_LINEAR_SOLVE, __pyx_k_DIVERGED_LINEAR_SOLVE, sizeof(__pyx_k_DIVERGED_LINEAR_SOLVE), 0, 0, 1, 1},
  {&__pyx_n_s_DIVERGED_SUBSPACE_EXHAUSTED, __pyx_k_DIVERGED_SUBSPACE_EXHAUSTED, sizeof(__pyx_k_DIVERGED_SUBSPACE_EXHAUSTED), 0, 0, 1, 1},
  {&__pyx_n_s_DIVERGED_SYMMETRY_LOST, __pyx_k_DIVERGED_SYMMETRY_LOST, sizeof(__pyx_k_DIVERGED_SYMMETRY_LOST), 0, 0, 1, 1},
  {&__pyx_n_s_DIVIDE, __pyx_k_DIVIDE, sizeof(__pyx_k_DIVIDE), 0, 0, 1, 1},
  {&__pyx_n_s_DS, __pyx_k_DS, sizeof(__pyx_k_DS), 0, 0, 1, 1},
  {&__pyx_n_s_DSMatType, __pyx_k_DSMatType, sizeof(__pyx_k_DSMatType), 0, 0, 1, 1},
  {&__pyx_n_s_DSParallelType, __pyx_k_DSParallelType, sizeof(__pyx_k_DSParallelType), 0, 0, 1, 1},
  {&__pyx_n_s_DSStateType, __pyx_k_DSStateType, sizeof(__pyx_k_DSStateType), 0, 0, 1, 1},
  {&__pyx_n_s_DSType, __pyx_k_DSType, sizeof(__pyx_k_DSType), 0, 0, 1, 1},
  {&__pyx_kp_s_DS_parallel_types_REDUNDANT_Eve, __pyx_k_DS_parallel_types_REDUNDANT_Eve, sizeof(__pyx_k_DS_parallel_types_REDUNDANT_Eve), 0, 0, 1, 0},
  {&__pyx_kp_s_DS_state_types_RAW_Not_processe, __pyx_k_DS_state_types_RAW_Not_processe, sizeof(__pyx_k_DS_state_types_RAW_Not_processe), 0, 0, 1, 0},
  {&__pyx_kp_s_DS_type, __pyx_k_DS_type, sizeof(__pyx_k_DS_type), 0, 0, 1, 0},
  {&__pyx_n_s_Dl, __pyx_k_Dl, sizeof(__pyx_k_Dl), 0, 0, 1, 1},
  {&__pyx_n_s_Dr, __pyx_k_Dr, sizeof(__pyx_k_Dr), 0, 0, 1, 1},
  {&__pyx_n_s_ELEMENTAL, __pyx_k_ELEMENTAL, sizeof(__pyx_k_ELEMENTAL), 0, 0, 1, 1},
  {&__pyx_n_s_ELLIPSE, __pyx_k_ELLIPSE, sizeof(__pyx_k_ELLIPSE), 0, 0, 1, 1},
  {&__pyx_n_s_ELPA, __pyx_k_ELPA, sizeof(__pyx_k_ELPA), 0, 0, 1, 1},
  {&__pyx_n_s_EPS, __pyx_k_EPS, sizeof(__pyx_k_EPS), 0, 0, 1, 1},
  {&__pyx_n_s_EPSBalance, __pyx_k_EPSBalance, sizeof(__pyx_k_EPSBalance), 0, 0, 1, 1},
  {&__pyx_n_s_EPSCISSExtraction, __pyx_k_EPSCISSExtraction, sizeof(__pyx_k_EPSCISSExtraction), 0, 0, 1, 1},
  {&__pyx_n_s_EPSCISSQuadRule, __pyx_k_EPSCISSQuadRule, sizeof(__pyx_k_EPSCISSQuadRule), 0, 0, 1, 1},
  {&__pyx_n_s_EPSConv, __pyx_k_EPSConv, sizeof(__pyx_k_EPSConv), 0, 0, 1, 1},
  {&__pyx_n_s_EPSConvergedReason, __pyx_k_EPSConvergedReason, sizeof(__pyx_k_EPSConvergedReason), 0, 0, 1, 1},
  {&__pyx_n_s_EPSErrorType, __pyx_k_EPSErrorType, sizeof(__pyx_k_EPSErrorType), 0, 0, 1, 1},
  {&__pyx_n_s_EPSExtraction, __pyx_k_EPSExtraction, sizeof(__pyx_k_EPSExtraction), 0, 0, 1, 1},
  {&__pyx_n_s_EPSLanczosReorthogType, __pyx_k_EPSLanczosReorthogType, sizeof(__pyx_k_EPSLanczosReorthogType), 0, 0, 1, 1},
  {&__pyx_n_s_EPSPowerShiftType, __pyx_k_EPSPowerShiftType, sizeof(__pyx_k_EPSPowerShiftType), 0, 0, 1, 1},
  {&__pyx_n_s_EPSProblemType, __pyx_k_EPSProblemType, sizeof(__pyx_k_EPSProblemType), 0, 0, 1, 1},
  {&__pyx_n_s_EPSStop, __pyx_k_EPSStop, sizeof(__pyx_k_EPSStop), 0, 0, 1, 1},
  {&__pyx_n_s_EPSType, __pyx_k_EPSType, sizeof(__pyx_k_EPSType), 0, 0, 1, 1},
  {&__pyx_n_s_EPSWhich, __pyx_k_EPSWhich, sizeof(__pyx_k_EPSWhich), 0, 0, 1, 1},
  {&__pyx_kp_s_EPS_CISS_extraction_technique_R, __pyx_k_EPS_CISS_extraction_technique_R, sizeof(__pyx_k_EPS_CISS_extraction_technique_R), 0, 0, 1, 0},
  {&__pyx_kp_s_EPS_CISS_quadrature_rule_TRAPEZ, __pyx_k_EPS_CISS_quadrature_rule_TRAPEZ, sizeof(__pyx_k_EPS_CISS_quadrature_rule_TRAPEZ), 0, 0, 1, 0},
  {&__pyx_kp_s_EPS_Lanczos_reorthogonalization, __pyx_k_EPS_Lanczos_reorthogonalization, sizeof(__pyx_k_EPS_Lanczos_reorthogonalization), 0, 0, 1, 0},
  {&__pyx_kp_s_EPS_Power_shift_type_CONSTANT_C, __pyx_k_EPS_Power_shift_type_CONSTANT_C, sizeof(__pyx_k_EPS_Power_shift_type_CONSTANT_C), 0, 0, 1, 0},
  {&__pyx_kp_s_EPS_convergence_reasons_CONVERG, __pyx_k_EPS_convergence_reasons_CONVERG, sizeof(__pyx_k_EPS_convergence_reasons_CONVERG), 0, 0, 1, 0},
  {&__pyx_kp_s_EPS_convergence_test_ABS_Absolu, __pyx_k_EPS_convergence_test_ABS_Absolu, sizeof(__pyx_k_EPS_convergence_test_ABS_Absolu), 0, 0, 1, 0},
  {&__pyx_kp_s_EPS_desired_part_of_spectrum_LA, __pyx_k_EPS_desired_part_of_spectrum_LA, sizeof(__pyx_k_EPS_desired_part_of_spectrum_LA), 0, 0, 1, 0},
  {&__pyx_kp_s_EPS_error_type_to_assess_accura, __pyx_k_EPS_error_type_to_assess_accura, sizeof(__pyx_k_EPS_error_type_to_assess_accura), 0, 0, 1, 0},
  {&__pyx_kp_s_EPS_extraction_technique_RITZ_S, __pyx_k_EPS_extraction_technique_RITZ_S, sizeof(__pyx_k_EPS_extraction_technique_RITZ_S), 0, 0, 1, 0},
  {&__pyx_kp_s_EPS_problem_type_HEP_Hermitian, __pyx_k_EPS_problem_type_HEP_Hermitian, sizeof(__pyx_k_EPS_problem_type_HEP_Hermitian), 0, 0, 1, 0},
  {&__pyx_kp_s_EPS_stopping_test_BASIC_Default, __pyx_k_EPS_stopping_test_BASIC_Default, sizeof(__pyx_k_EPS_stopping_test_BASIC_Default), 0, 0, 1, 0},
  {&__pyx_kp_s_EPS_type_Native_sparse_eigensol, __pyx_k_EPS_type_Native_sparse_eigensol, sizeof(__pyx_k_EPS_type_Native_sparse_eigensol), 0, 0, 1, 0},
  {&__pyx_kp_s_EPS_type_of_balancing_used_for, __pyx_k_EPS_type_of_balancing_used_for, sizeof(__pyx_k_EPS_type_of_balancing_used_for), 0, 0, 1, 0},
  {&__pyx_n_s_EVSL, __pyx_k_EVSL, sizeof(__pyx_k_EVSL), 0, 0, 1, 1},
  {&__pyx_n_s_EXP, __pyx_k_EXP, sizeof(__pyx_k_EXP), 0, 0, 1, 1},
  {&__pyx_n_s_EXPLICIT, __pyx_k_EXPLICIT, sizeof(__pyx_k_EXPLICIT), 0, 0, 1, 1},
  {&__pyx_n_s_EXPOKIT, __pyx_k_EXPOKIT, sizeof(__pyx_k_EXPOKIT), 0, 0, 1, 1},
  {&__pyx_n_s_Error, __pyx_k_Error, sizeof(__pyx_k_Error), 0, 0, 1, 1},
  {&__pyx_n_s_ErrorType, __pyx_k_ErrorType, sizeof(__pyx_k_ErrorType), 0, 0, 1, 1},
  {&__pyx_n_s_Extract, __pyx_k_Extract, sizeof(__pyx_k_Extract), 0, 0, 1, 1},
  {&__pyx_n_s_Extraction, __pyx_k_Extraction, sizeof(__pyx_k_Extraction), 0, 0, 1, 1},
  {&__pyx_n_s_F, __pyx_k_F, sizeof(__pyx_k_F), 0, 0, 1, 1},
  {&__pyx_n_s_FEAST, __pyx_k_FEAST, sizeof(__pyx_k_FEAST), 0, 0, 1, 1},
  {&__pyx_n_s_FILTER, __pyx_k_FILTER, sizeof(__pyx_k_FILTER), 0, 0, 1, 1},
  {&__pyx_n_s_FN, __pyx_k_FN, sizeof(__pyx_k_FN), 0, 0, 1, 1},
  {&__pyx_n_s_FNCombineType, __pyx_k_FNCombineType, sizeof(__pyx_k_FNCombineType), 0, 0, 1, 1},
  {&__pyx_n_s_FNParallelType, __pyx_k_FNParallelType, sizeof(__pyx_k_FNParallelType), 0, 0, 1, 1},
  {&__pyx_n_s_FNType, __pyx_k_FNType, sizeof(__pyx_k_FNType), 0, 0, 1, 1},
  {&__pyx_kp_s_FN_parallel_types_REDUNDANT_Eve, __pyx_k_FN_parallel_types_REDUNDANT_Eve, sizeof(__pyx_k_FN_parallel_types_REDUNDANT_Eve), 0, 0, 1, 0},
  {&__pyx_kp_s_FN_type, __pyx_k_FN_type, sizeof(__pyx_k_FN_type), 0, 0, 1, 0},
  {&__pyx_kp_s_FN_type_of_combination_of_child, __pyx_k_FN_type_of_combination_of_child, sizeof(__pyx_k_FN_type_of_combination_of_child), 0, 0, 1, 0},
  {&__pyx_n_s_FULL, __pyx_k_FULL, sizeof(__pyx_k_FULL), 0, 0, 1, 1},
  {&__pyx_n_s_GD, __pyx_k_GD, sizeof(__pyx_k_GD), 0, 0, 1, 1},
  {&__pyx_n_s_GENERAL, __pyx_k_GENERAL, sizeof(__pyx_k_GENERAL), 0, 0, 1, 1},
  {&__pyx_n_s_GENERALIZED, __pyx_k_GENERALIZED, sizeof(__pyx_k_GENERALIZED), 0, 0, 1, 1},
  {&__pyx_n_s_GHEP, __pyx_k_GHEP, sizeof(__pyx_k_GHEP), 0, 0, 1, 1},
  {&__pyx_n_s_GHIEP, __pyx_k_GHIEP, sizeof(__pyx_k_GHIEP), 0, 0, 1, 1},
  {&__pyx_kp_s_GIT_Date, __pyx_k_GIT_Date, sizeof(__pyx_k_GIT_Date), 0, 0, 1, 0},
  {&__pyx_n_s_GNHEP, __pyx_k_GNHEP, sizeof(__pyx_k_GNHEP), 0, 0, 1, 1},
  {&__pyx_n_s_GS, __pyx_k_GS, sizeof(__pyx_k_GS), 0, 0, 1, 1},
  {&__pyx_n_s_GSVD, __pyx_k_GSVD, sizeof(__pyx_k_GSVD), 0, 0, 1, 1},
  {&__pyx_n_s_GYROSCOPIC, __pyx_k_GYROSCOPIC, sizeof(__pyx_k_GYROSCOPIC), 0, 0, 1, 1},
  {&__pyx_n_s_HANKEL, __pyx_k_HANKEL, sizeof(__pyx_k_HANKEL), 0, 0, 1, 1},
  {&__pyx_n_s_HARMONIC, __pyx_k_HARMONIC, sizeof(__pyx_k_HARMONIC), 0, 0, 1, 1},
  {&__pyx_n_s_HARMONIC_LARGEST, __pyx_k_HARMONIC_LARGEST, sizeof(__pyx_k_HARMONIC_LARGEST), 0, 0, 1, 1},
  {&__pyx_n_s_HARMONIC_RELATIVE, __pyx_k_HARMONIC_RELATIVE, sizeof(__pyx_k_HARMONIC_RELATIVE), 0, 0, 1, 1},
  {&__pyx_n_s_HARMONIC_RIGHT, __pyx_k_HARMONIC_RIGHT, sizeof(__pyx_k_HARMONIC_RIGHT), 0, 0, 1, 1},
  {&__pyx_n_s_HEP, __pyx_k_HEP, sizeof(__pyx_k_HEP), 0, 0, 1, 1},
  {&__pyx_n_s_HERMITE, __pyx_k_HERMITE, sizeof(__pyx_k_HERMITE), 0, 0, 1, 1},
  {&__pyx_n_s_HERMITIAN, __pyx_k_HERMITIAN, sizeof(__pyx_k_HERMITIAN), 0, 0, 1, 1},
  {&__pyx_n_s_HYPERBOLIC, __pyx_k_HYPERBOLIC, sizeof(__pyx_k_HYPERBOLIC), 0, 0, 1, 1},
  {&__pyx_n_s_IFNEEDED, __pyx_k_IFNEEDED, sizeof(__pyx_k_IFNEEDED), 0, 0, 1, 1},
  {&__pyx_n_s_INPLACE, __pyx_k_INPLACE, sizeof(__pyx_k_INPLACE), 0, 0, 1, 1},
  {&__pyx_n_s_INTERMEDIATE, __pyx_k_INTERMEDIATE, sizeof(__pyx_k_INTERMEDIATE), 0, 0, 1, 1},
  {&__pyx_n_s_INTERPOL, __pyx_k_INTERPOL, sizeof(__pyx_k_INTERPOL), 0, 0, 1, 1},
  {&__pyx_n_s_INTERVAL, __pyx_k_INTERVAL, sizeof(__pyx_k_INTERVAL), 0, 0, 1, 1},
  {&__pyx_n_s_INVSQRT, __pyx_k_INVSQRT, sizeof(__pyx_k_INVSQRT), 0, 0, 1, 1},
  {&__pyx_n_s_ITERATING, __pyx_k_ITERATING, sizeof(__pyx_k_ITERATING), 0, 0, 1, 1},
  {&__pyx_n_s_IntType, __pyx_k_IntType, sizeof(__pyx_k_IntType), 0, 0, 1, 1},
  {&__pyx_n_s_J, __pyx_k_J, sizeof(__pyx_k_J), 0, 0, 1, 1},
  {&__pyx_n_s_JD, __pyx_k_JD, sizeof(__pyx_k_JD), 0, 0, 1, 1},
  {&__pyx_n_s_JDProjection, __pyx_k_JDProjection, sizeof(__pyx_k_JDProjection), 0, 0, 1, 1},
  {&__pyx_n_s_KRYLOV, __pyx_k_KRYLOV, sizeof(__pyx_k_KRYLOV), 0, 0, 1, 1},
  {&__pyx_n_s_KRYLOVSCHUR, __pyx_k_KRYLOVSCHUR, sizeof(__pyx_k_KRYLOVSCHUR), 0, 0, 1, 1},
  {&__pyx_n_s_LAGUERRE, __pyx_k_LAGUERRE, sizeof(__pyx_k_LAGUERRE), 0, 0, 1, 1},
  {&__pyx_n_s_LANCZOS, __pyx_k_LANCZOS, sizeof(__pyx_k_LANCZOS), 0, 0, 1, 1},
  {&__pyx_n_s_LAPACK, __pyx_k_LAPACK, sizeof(__pyx_k_LAPACK), 0, 0, 1, 1},
  {&__pyx_n_s_LARGEST, __pyx_k_LARGEST, sizeof(__pyx_k_LARGEST), 0, 0, 1, 1},
  {&__pyx_n_s_LARGEST_IMAGINARY, __pyx_k_LARGEST_IMAGINARY, sizeof(__pyx_k_LARGEST_IMAGINARY), 0, 0, 1, 1},
  {&__pyx_n_s_LARGEST_MAGNITUDE, __pyx_k_LARGEST_MAGNITUDE, sizeof(__pyx_k_LARGEST_MAGNITUDE), 0, 0, 1, 1},
  {&__pyx_n_s_LARGEST_REAL, __pyx_k_LARGEST_REAL, sizeof(__pyx_k_LARGEST_REAL), 0, 0, 1, 1},
  {&__pyx_n_s_LEGENDRE, __pyx_k_LEGENDRE, sizeof(__pyx_k_LEGENDRE), 0, 0, 1, 1},
  {&__pyx_n_s_LINEAR, __pyx_k_LINEAR, sizeof(__pyx_k_LINEAR), 0, 0, 1, 1},
  {&__pyx_n_s_LOBPCG, __pyx_k_LOBPCG, sizeof(__pyx_k_LOBPCG), 0, 0, 1, 1},
  {&__pyx_n_s_LOCAL, __pyx_k_LOCAL, sizeof(__pyx_k_LOCAL), 0, 0, 1, 1},
  {&__pyx_n_s_LOG, __pyx_k_LOG, sizeof(__pyx_k_LOG), 0, 0, 1, 1},
  {&__pyx_n_s_LOWER, __pyx_k_LOWER, sizeof(__pyx_k_LOWER), 0, 0, 1, 1},
  {&__pyx_n_s_LYAPII, __pyx_k_LYAPII, sizeof(__pyx_k_LYAPII), 0, 0, 1, 1},
  {&__pyx_n_s_LanczosReorthogType, __pyx_k_LanczosReorthogType, sizeof(__pyx_k_LanczosReorthogType), 0, 0, 1, 1},
  {&__pyx_n_s_MAT, __pyx_k_MAT, sizeof(__pyx_k_MAT), 0, 0, 1, 1},
  {&__pyx_n_s_MAXIT, __pyx_k_MAXIT, sizeof(__pyx_k_MAXIT), 0, 0, 1, 1},
  {&__pyx_n_s_MBE, __pyx_k_MBE, sizeof(__pyx_k_MBE), 0, 0, 1, 1},
  {&__pyx_n_s_MFN, __pyx_k_MFN, sizeof(__pyx_k_MFN), 0, 0, 1, 1},
  {&__pyx_n_s_MFNConvergedReason, __pyx_k_MFNConvergedReason, sizeof(__pyx_k_MFNConvergedReason), 0, 0, 1, 1},
  {&__pyx_n_s_MFNType, __pyx_k_MFNType, sizeof(__pyx_k_MFNType), 0, 0, 1, 1},
  {&__pyx_kp_s_MFN_type_Action_of_a_matrix_fun, __pyx_k_MFN_type_Action_of_a_matrix_fun, sizeof(__pyx_k_MFN_type_Action_of_a_matrix_fun), 0, 0, 1, 0},
  {&__pyx_n_s_MGS, __pyx_k_MGS, sizeof(__pyx_k_MGS), 0, 0, 1, 1},
  {&__pyx_n_s_MONOMIAL, __pyx_k_MONOMIAL, sizeof(__pyx_k_MONOMIAL), 0, 0, 1, 1},
  {&__pyx_n_s_MULTIPLE, __pyx_k_MULTIPLE, sizeof(__pyx_k_MULTIPLE), 0, 0, 1, 1},
  {&__pyx_n_s_MULTIPLY, __pyx_k_MULTIPLY, sizeof(__pyx_k_MULTIPLY), 0, 0, 1, 1},
  {&__pyx_n_s_MatMode, __pyx_k_MatMode, sizeof(__pyx_k_MatMode), 0, 0, 1, 1},
  {&__pyx_n_s_MatMultType, __pyx_k_MatMultType, sizeof(__pyx_k_MatMultType), 0, 0, 1, 1},
  {&__pyx_n_s_MatType, __pyx_k_MatType, sizeof(__pyx_k_MatType), 0, 0, 1, 1},
  {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1},
  {&__pyx_n_s_NARNOLDI, __pyx_k_NARNOLDI, sizeof(__pyx_k_NARNOLDI), 0, 0, 1, 1},
  {&__pyx_n_s_NEP, __pyx_k_NEP, sizeof(__pyx_k_NEP), 0, 0, 1, 1},
  {&__pyx_n_s_NEPCISSExtraction, __pyx_k_NEPCISSExtraction, sizeof(__pyx_k_NEPCISSExtraction), 0, 0, 1, 1},
  {&__pyx_n_s_NEPConv, __pyx_k_NEPConv, sizeof(__pyx_k_NEPConv), 0, 0, 1, 1},
  {&__pyx_n_s_NEPConvergedReason, __pyx_k_NEPConvergedReason, sizeof(__pyx_k_NEPConvergedReason), 0, 0, 1, 1},
  {&__pyx_n_s_NEPErrorType, __pyx_k_NEPErrorType, sizeof(__pyx_k_NEPErrorType), 0, 0, 1, 1},
  {&__pyx_n_s_NEPProblemType, __pyx_k_NEPProblemType, sizeof(__pyx_k_NEPProblemType), 0, 0, 1, 1},
  {&__pyx_n_s_NEPRefine, __pyx_k_NEPRefine, sizeof(__pyx_k_NEPRefine), 0, 0, 1, 1},
  {&__pyx_n_s_NEPRefineScheme, __pyx_k_NEPRefineScheme, sizeof(__pyx_k_NEPRefineScheme), 0, 0, 1, 1},
  {&__pyx_n_s_NEPStop, __pyx_k_NEPStop, sizeof(__pyx_k_NEPStop), 0, 0, 1, 1},
  {&__pyx_n_s_NEPType, __pyx_k_NEPType, sizeof(__pyx_k_NEPType), 0, 0, 1, 1},
  {&__pyx_n_s_NEPWhich, __pyx_k_NEPWhich, sizeof(__pyx_k_NEPWhich), 0, 0, 1, 1},
  {&__pyx_kp_s_NEP_CISS_extraction_technique_R, __pyx_k_NEP_CISS_extraction_technique_R, sizeof(__pyx_k_NEP_CISS_extraction_technique_R), 0, 0, 1, 0},
  {&__pyx_kp_s_NEP_convergence_reasons_CONVERG, __pyx_k_NEP_convergence_reasons_CONVERG, sizeof(__pyx_k_NEP_convergence_reasons_CONVERG), 0, 0, 1, 0},
  {&__pyx_kp_s_NEP_convergence_test_ABS_Absolu, __pyx_k_NEP_convergence_test_ABS_Absolu, sizeof(__pyx_k_NEP_convergence_test_ABS_Absolu), 0, 0, 1, 0},
  {&__pyx_kp_s_NEP_desired_part_of_spectrum_LA, __pyx_k_NEP_desired_part_of_spectrum_LA, sizeof(__pyx_k_NEP_desired_part_of_spectrum_LA), 0, 0, 1, 0},
  {&__pyx_kp_s_NEP_error_type_to_assess_accura, __pyx_k_NEP_error_type_to_assess_accura, sizeof(__pyx_k_NEP_error_type_to_assess_accura), 0, 0, 1, 0},
  {&__pyx_kp_s_NEP_problem_type_GENERAL_Genera, __pyx_k_NEP_problem_type_GENERAL_Genera, sizeof(__pyx_k_NEP_problem_type_GENERAL_Genera), 0, 0, 1, 0},
  {&__pyx_kp_s_NEP_refinement_strategy_NONE_No, __pyx_k_NEP_refinement_strategy_NONE_No, sizeof(__pyx_k_NEP_refinement_strategy_NONE_No), 0, 0, 1, 0},
  {&__pyx_kp_s_NEP_scheme_for_solving_linear_s, __pyx_k_NEP_scheme_for_solving_linear_s, sizeof(__pyx_k_NEP_scheme_for_solving_linear_s), 0, 0, 1, 0},
  {&__pyx_kp_s_NEP_stopping_test_BASIC_Default, __pyx_k_NEP_stopping_test_BASIC_Default, sizeof(__pyx_k_NEP_stopping_test_BASIC_Default), 0, 0, 1, 0},
  {&__pyx_kp_s_NEP_type_Nonlinear_eigensolvers, __pyx_k_NEP_type_Nonlinear_eigensolvers, sizeof(__pyx_k_NEP_type_Nonlinear_eigensolvers), 0, 0, 1, 0},
  {&__pyx_n_s_NEVER, __pyx_k_NEVER, sizeof(__pyx_k_NEVER), 0, 0, 1, 1},
  {&__pyx_n_s_NHEP, __pyx_k_NHEP, sizeof(__pyx_k_NHEP), 0, 0, 1, 1},
  {&__pyx_n_s_NHEPTS, __pyx_k_NHEPTS, sizeof(__pyx_k_NHEPTS), 0, 0, 1, 1},
  {&__pyx_n_s_NLEIGS, __pyx_k_NLEIGS, sizeof(__pyx_k_NLEIGS), 0, 0, 1, 1},
  {&__pyx_n_s_NONE, __pyx_k_NONE, sizeof(__pyx_k_NONE), 0, 0, 1, 1},
  {&__pyx_n_s_NORM, __pyx_k_NORM, sizeof(__pyx_k_NORM), 0, 0, 1, 1},
  {&__pyx_n_s_ONESIDE, __pyx_k_ONESIDE, sizeof(__pyx_k_ONESIDE), 0, 0, 1, 1},
  {&__pyx_n_s_ORTHOGONAL, __pyx_k_ORTHOGONAL, sizeof(__pyx_k_ORTHOGONAL), 0, 0, 1, 1},
  {&__pyx_n_s_OrthogBlockType, __pyx_k_OrthogBlockType, sizeof(__pyx_k_OrthogBlockType), 0, 0, 1, 1},
  {&__pyx_n_s_OrthogRefineType, __pyx_k_OrthogRefineType, sizeof(__pyx_k_OrthogRefineType), 0, 0, 1, 1},
  {&__pyx_n_s_OrthogType, __pyx_k_OrthogType, sizeof(__pyx_k_OrthogType), 0, 0, 1, 1},
  {&__pyx_n_s_P, __pyx_k_P, sizeof(__pyx_k_P), 0, 0, 1, 1},
  {&__pyx_n_s_PARTIAL, __pyx_k_PARTIAL, sizeof(__pyx_k_PARTIAL), 0, 0, 1, 1},
  {&__pyx_n_s_PEP, __pyx_k_PEP, sizeof(__pyx_k_PEP), 0, 0, 1, 1},
  {&__pyx_n_s_PEPBasis, __pyx_k_PEPBasis, sizeof(__pyx_k_PEPBasis), 0, 0, 1, 1},
  {&__pyx_n_s_PEPCISSExtraction, __pyx_k_PEPCISSExtraction, sizeof(__pyx_k_PEPCISSExtraction), 0, 0, 1, 1},
  {&__pyx_n_s_PEPConv, __pyx_k_PEPConv, sizeof(__pyx_k_PEPConv), 0, 0, 1, 1},
  {&__pyx_n_s_PEPConvergedReason, __pyx_k_PEPConvergedReason, sizeof(__pyx_k_PEPConvergedReason), 0, 0, 1, 1},
  {&__pyx_n_s_PEPErrorType, __pyx_k_PEPErrorType, sizeof(__pyx_k_PEPErrorType), 0, 0, 1, 1},
  {&__pyx_n_s_PEPExtract, __pyx_k_PEPExtract, sizeof(__pyx_k_PEPExtract), 0, 0, 1, 1},
  {&__pyx_n_s_PEPJDProjection, __pyx_k_PEPJDProjection, sizeof(__pyx_k_PEPJDProjection), 0, 0, 1, 1},
  {&__pyx_n_s_PEPProblemType, __pyx_k_PEPProblemType, sizeof(__pyx_k_PEPProblemType), 0, 0, 1, 1},
  {&__pyx_n_s_PEPRefine, __pyx_k_PEPRefine, sizeof(__pyx_k_PEPRefine), 0, 0, 1, 1},
  {&__pyx_n_s_PEPRefineScheme, __pyx_k_PEPRefineScheme, sizeof(__pyx_k_PEPRefineScheme), 0, 0, 1, 1},
  {&__pyx_n_s_PEPScale, __pyx_k_PEPScale, sizeof(__pyx_k_PEPScale), 0, 0, 1, 1},
  {&__pyx_n_s_PEPStop, __pyx_k_PEPStop, sizeof(__pyx_k_PEPStop), 0, 0, 1, 1},
  {&__pyx_n_s_PEPType, __pyx_k_PEPType, sizeof(__pyx_k_PEPType), 0, 0, 1, 1},
  {&__pyx_n_s_PEPWhich, __pyx_k_PEPWhich, sizeof(__pyx_k_PEPWhich), 0, 0, 1, 1},
  {&__pyx_kp_s_PEP_CISS_extraction_technique_R, __pyx_k_PEP_CISS_extraction_technique_R, sizeof(__pyx_k_PEP_CISS_extraction_technique_R), 0, 0, 1, 0},
  {&__pyx_kp_s_PEP_basis_type_for_the_represen, __pyx_k_PEP_basis_type_for_the_represen, sizeof(__pyx_k_PEP_basis_type_for_the_represen), 0, 0, 1, 0},
  {&__pyx_kp_s_PEP_convergence_reasons_CONVERG, __pyx_k_PEP_convergence_reasons_CONVERG, sizeof(__pyx_k_PEP_convergence_reasons_CONVERG), 0, 0, 1, 0},
  {&__pyx_kp_s_PEP_convergence_test_ABS_Absolu, __pyx_k_PEP_convergence_test_ABS_Absolu, sizeof(__pyx_k_PEP_convergence_test_ABS_Absolu), 0, 0, 1, 0},
  {&__pyx_kp_s_PEP_desired_part_of_spectrum_LA, __pyx_k_PEP_desired_part_of_spectrum_LA, sizeof(__pyx_k_PEP_desired_part_of_spectrum_LA), 0, 0, 1, 0},
  {&__pyx_kp_s_PEP_error_type_to_assess_accura, __pyx_k_PEP_error_type_to_assess_accura, sizeof(__pyx_k_PEP_error_type_to_assess_accura), 0, 0, 1, 0},
  {&__pyx_kp_s_PEP_extraction_strategy_used_to, __pyx_k_PEP_extraction_strategy_used_to, sizeof(__pyx_k_PEP_extraction_strategy_used_to), 0, 0, 1, 0},
  {&__pyx_kp_s_PEP_problem_type_GENERAL_No_str, __pyx_k_PEP_problem_type_GENERAL_No_str, sizeof(__pyx_k_PEP_problem_type_GENERAL_No_str), 0, 0, 1, 0},
  {&__pyx_kp_s_PEP_refinement_strategy_NONE_No, __pyx_k_PEP_refinement_strategy_NONE_No, sizeof(__pyx_k_PEP_refinement_strategy_NONE_No), 0, 0, 1, 0},
  {&__pyx_kp_s_PEP_scaling_strategy_NONE_No_sc, __pyx_k_PEP_scaling_strategy_NONE_No_sc, sizeof(__pyx_k_PEP_scaling_strategy_NONE_No_sc), 0, 0, 1, 0},
  {&__pyx_kp_s_PEP_scheme_for_solving_linear_s, __pyx_k_PEP_scheme_for_solving_linear_s, sizeof(__pyx_k_PEP_scheme_for_solving_linear_s), 0, 0, 1, 0},
  {&__pyx_kp_s_PEP_stopping_test_BASIC_Default, __pyx_k_PEP_stopping_test_BASIC_Default, sizeof(__pyx_k_PEP_stopping_test_BASIC_Default), 0, 0, 1, 0},
  {&__pyx_kp_s_PEP_type_Polynomial_eigensolver, __pyx_k_PEP_type_Polynomial_eigensolver, sizeof(__pyx_k_PEP_type_Polynomial_eigensolver), 0, 0, 1, 0},
  {&__pyx_kp_s_PEP_type_of_projection_to_be_us, __pyx_k_PEP_type_of_projection_to_be_us, sizeof(__pyx_k_PEP_type_of_projection_to_be_us), 0, 0, 1, 0},
  {&__pyx_n_s_PERIODIC, __pyx_k_PERIODIC, sizeof(__pyx_k_PERIODIC), 0, 0, 1, 1},
  {&__pyx_n_s_PGNHEP, __pyx_k_PGNHEP, sizeof(__pyx_k_PGNHEP), 0, 0, 1, 1},
  {&__pyx_n_s_PHI, __pyx_k_PHI, sizeof(__pyx_k_PHI), 0, 0, 1, 1},
  {&__pyx_n_s_POLYGON, __pyx_k_POLYGON, sizeof(__pyx_k_POLYGON), 0, 0, 1, 1},
  {&__pyx_n_s_POWER, __pyx_k_POWER, sizeof(__pyx_k_POWER), 0, 0, 1, 1},
  {&__pyx_n_s_PRECOND, __pyx_k_PRECOND, sizeof(__pyx_k_PRECOND), 0, 0, 1, 1},
  {&__pyx_n_s_PRIMME, __pyx_k_PRIMME, sizeof(__pyx_k_PRIMME), 0, 0, 1, 1},
  {&__pyx_n_s_ParallelType, __pyx_k_ParallelType, sizeof(__pyx_k_ParallelType), 0, 0, 1, 1},
  {&__pyx_n_s_PowerShiftType, __pyx_k_PowerShiftType, sizeof(__pyx_k_PowerShiftType), 0, 0, 1, 1},
  {&__pyx_n_s_ProblemType, __pyx_k_ProblemType, sizeof(__pyx_k_ProblemType), 0, 0, 1, 1},
  {&__pyx_n_s_Q, __pyx_k_Q, sizeof(__pyx_k_Q), 0, 0, 1, 1},
  {&__pyx_n_s_QARNOLDI, __pyx_k_QARNOLDI, sizeof(__pyx_k_QARNOLDI), 0, 0, 1, 1},
  {&__pyx_n_s_QR, __pyx_k_QR, sizeof(__pyx_k_QR), 0, 0, 1, 1},
  {&__pyx_n_s_QR_CAA, __pyx_k_QR_CAA, sizeof(__pyx_k_QR_CAA), 0, 0, 1, 1},
  {&__pyx_n_s_QuadRule, __pyx_k_QuadRule, sizeof(__pyx_k_QuadRule), 0, 0, 1, 1},
  {&__pyx_n_s_R, __pyx_k_R, sizeof(__pyx_k_R), 0, 0, 1, 1},
  {&__pyx_n_s_RANDOMIZED, __pyx_k_RANDOMIZED, sizeof(__pyx_k_RANDOMIZED), 0, 0, 1, 1},
  {&__pyx_n_s_RATIONAL, __pyx_k_RATIONAL, sizeof(__pyx_k_RATIONAL), 0, 0, 1, 1},
  {&__pyx_n_s_RAW, __pyx_k_RAW, sizeof(__pyx_k_RAW), 0, 0, 1, 1},
  {&__pyx_n_s_RAYLEIGH, __pyx_k_RAYLEIGH, sizeof(__pyx_k_RAYLEIGH), 0, 0, 1, 1},
  {&__pyx_n_s_REDUNDANT, __pyx_k_REDUNDANT, sizeof(__pyx_k_REDUNDANT), 0, 0, 1, 1},
  {&__pyx_n_s_REFINE, __pyx_k_REFINE, sizeof(__pyx_k_REFINE), 0, 0, 1, 1},
  {&__pyx_n_s_REFINED, __pyx_k_REFINED, sizeof(__pyx_k_REFINED), 0, 0, 1, 1},
  {&__pyx_n_s_REFINED_HARMONIC, __pyx_k_REFINED_HARMONIC, sizeof(__pyx_k_REFINED_HARMONIC), 0, 0, 1, 1},
  {&__pyx_n_s_REL, __pyx_k_REL, sizeof(__pyx_k_REL), 0, 0, 1, 1},
  {&__pyx_n_s_RELATIVE, __pyx_k_RELATIVE, sizeof(__pyx_k_RELATIVE), 0, 0, 1, 1},
  {&__pyx_n_s_RESIDUAL, __pyx_k_RESIDUAL, sizeof(__pyx_k_RESIDUAL), 0, 0, 1, 1},
  {&__pyx_n_s_RG, __pyx_k_RG, sizeof(__pyx_k_RG), 0, 0, 1, 1},
  {&__pyx_n_s_RGQuadRule, __pyx_k_RGQuadRule, sizeof(__pyx_k_RGQuadRule), 0, 0, 1, 1},
  {&__pyx_n_s_RGType, __pyx_k_RGType, sizeof(__pyx_k_RGType), 0, 0, 1, 1},
  {&__pyx_kp_s_RG_quadrature_rule_for_contour, __pyx_k_RG_quadrature_rule_for_contour, sizeof(__pyx_k_RG_quadrature_rule_for_contour), 0, 0, 1, 0},
  {&__pyx_kp_s_RG_type, __pyx_k_RG_type, sizeof(__pyx_k_RG_type), 0, 0, 1, 0},
  {&__pyx_n_s_RII, __pyx_k_RII, sizeof(__pyx_k_RII), 0, 0, 1, 1},
  {&__pyx_n_s_RING, __pyx_k_RING, sizeof(__pyx_k_RING), 0, 0, 1, 1},
  {&__pyx_n_s_RITZ, __pyx_k_RITZ, sizeof(__pyx_k_RITZ), 0, 0, 1, 1},
  {&__pyx_n_s_RQCG, __pyx_k_RQCG, sizeof(__pyx_k_RQCG), 0, 0, 1, 1},
  {&__pyx_n_s_RealType, __pyx_k_RealType, sizeof(__pyx_k_RealType), 0, 0, 1, 1},
  {&__pyx_n_s_Refine, __pyx_k_Refine, sizeof(__pyx_k_Refine), 0, 0, 1, 1},
  {&__pyx_n_s_RefineScheme, __pyx_k_RefineScheme, sizeof(__pyx_k_RefineScheme), 0, 0, 1, 1},
  {&__pyx_n_s_RefineType, __pyx_k_RefineType, sizeof(__pyx_k_RefineType), 0, 0, 1, 1},
  {&__pyx_n_s_SCALAPACK, __pyx_k_SCALAPACK, sizeof(__pyx_k_SCALAPACK), 0, 0, 1, 1},
  {&__pyx_n_s_SCALAR, __pyx_k_SCALAR, sizeof(__pyx_k_SCALAR), 0, 0, 1, 1},
  {&__pyx_n_s_SCHUR, __pyx_k_SCHUR, sizeof(__pyx_k_SCHUR), 0, 0, 1, 1},
  {&__pyx_n_s_SELECTIVE, __pyx_k_SELECTIVE, sizeof(__pyx_k_SELECTIVE), 0, 0, 1, 1},
  {&__pyx_n_s_SHELL, __pyx_k_SHELL, sizeof(__pyx_k_SHELL), 0, 0, 1, 1},
  {&__pyx_n_s_SHIFT, __pyx_k_SHIFT, sizeof(__pyx_k_SHIFT), 0, 0, 1, 1},
  {&__pyx_n_s_SIMPLE, __pyx_k_SIMPLE, sizeof(__pyx_k_SIMPLE), 0, 0, 1, 1},
  {&__pyx_n_s_SINGLE, __pyx_k_SINGLE, sizeof(__pyx_k_SINGLE), 0, 0, 1, 1},
  {&__pyx_n_s_SINVERT, __pyx_k_SINVERT, sizeof(__pyx_k_SINVERT), 0, 0, 1, 1},
  {&__pyx_kp_s_SLEPc_SLEPc_pyx, __pyx_k_SLEPc_SLEPc_pyx, sizeof(__pyx_k_SLEPc_SLEPc_pyx), 0, 0, 1, 0},
  {&__pyx_n_s_SLP, __pyx_k_SLP, sizeof(__pyx_k_SLP), 0, 0, 1, 1},
  {&__pyx_n_s_SMALLEST, __pyx_k_SMALLEST, sizeof(__pyx_k_SMALLEST), 0, 0, 1, 1},
  {&__pyx_n_s_SMALLEST_IMAGINARY, __pyx_k_SMALLEST_IMAGINARY, sizeof(__pyx_k_SMALLEST_IMAGINARY), 0, 0, 1, 1},
  {&__pyx_n_s_SMALLEST_MAGNITUDE, __pyx_k_SMALLEST_MAGNITUDE, sizeof(__pyx_k_SMALLEST_MAGNITUDE), 0, 0, 1, 1},
  {&__pyx_n_s_SMALLEST_REAL, __pyx_k_SMALLEST_REAL, sizeof(__pyx_k_SMALLEST_REAL), 0, 0, 1, 1},
  {&__pyx_n_s_SQRT, __pyx_k_SQRT, sizeof(__pyx_k_SQRT), 0, 0, 1, 1},
  {&__pyx_n_s_ST, __pyx_k_ST, sizeof(__pyx_k_ST), 0, 0, 1, 1},
  {&__pyx_n_s_STANDARD, __pyx_k_STANDARD, sizeof(__pyx_k_STANDARD), 0, 0, 1, 1},
  {&__pyx_n_s_STMatMode, __pyx_k_STMatMode, sizeof(__pyx_k_STMatMode), 0, 0, 1, 1},
  {&__pyx_n_s_STOAR, __pyx_k_STOAR, sizeof(__pyx_k_STOAR), 0, 0, 1, 1},
  {&__pyx_n_s_STRUCTURED, __pyx_k_STRUCTURED, sizeof(__pyx_k_STRUCTURED), 0, 0, 1, 1},
  {&__pyx_n_s_STType, __pyx_k_STType, sizeof(__pyx_k_STType), 0, 0, 1, 1},
  {&__pyx_kp_s_ST_matrix_mode_COPY_A_working_c, __pyx_k_ST_matrix_mode_COPY_A_working_c, sizeof(__pyx_k_ST_matrix_mode_COPY_A_working_c), 0, 0, 1, 0},
  {&__pyx_kp_s_ST_types_SHELL_User_defined_SHI, __pyx_k_ST_types_SHELL_User_defined_SHI, sizeof(__pyx_k_ST_types_SHELL_User_defined_SHI), 0, 0, 1, 0},
  {&__pyx_n_s_SUBSPACE, __pyx_k_SUBSPACE, sizeof(__pyx_k_SUBSPACE), 0, 0, 1, 1},
  {&__pyx_n_s_SVD, __pyx_k_SVD, sizeof(__pyx_k_SVD), 0, 0, 1, 1},
  {&__pyx_n_s_SVDConv, __pyx_k_SVDConv, sizeof(__pyx_k_SVDConv), 0, 0, 1, 1},
  {&__pyx_n_s_SVDConvergedReason, __pyx_k_SVDConvergedReason, sizeof(__pyx_k_SVDConvergedReason), 0, 0, 1, 1},
  {&__pyx_n_s_SVDErrorType, __pyx_k_SVDErrorType, sizeof(__pyx_k_SVDErrorType), 0, 0, 1, 1},
  {&__pyx_n_s_SVDProblemType, __pyx_k_SVDProblemType, sizeof(__pyx_k_SVDProblemType), 0, 0, 1, 1},
  {&__pyx_n_s_SVDStop, __pyx_k_SVDStop, sizeof(__pyx_k_SVDStop), 0, 0, 1, 1},
  {&__pyx_n_s_SVDTRLanczosGBidiag, __pyx_k_SVDTRLanczosGBidiag, sizeof(__pyx_k_SVDTRLanczosGBidiag), 0, 0, 1, 1},
  {&__pyx_n_s_SVDType, __pyx_k_SVDType, sizeof(__pyx_k_SVDType), 0, 0, 1, 1},
  {&__pyx_n_s_SVDWhich, __pyx_k_SVDWhich, sizeof(__pyx_k_SVDWhich), 0, 0, 1, 1},
  {&__pyx_kp_s_SVD_TRLanczos_bidiagonalization, __pyx_k_SVD_TRLanczos_bidiagonalization, sizeof(__pyx_k_SVD_TRLanczos_bidiagonalization), 0, 0, 1, 0},
  {&__pyx_kp_s_SVD_convergence_reasons_CONVERG, __pyx_k_SVD_convergence_reasons_CONVERG, sizeof(__pyx_k_SVD_convergence_reasons_CONVERG), 0, 0, 1, 0},
  {&__pyx_kp_s_SVD_convergence_test_ABS_Absolu, __pyx_k_SVD_convergence_test_ABS_Absolu, sizeof(__pyx_k_SVD_convergence_test_ABS_Absolu), 0, 0, 1, 0},
  {&__pyx_kp_s_SVD_desired_part_of_spectrum_LA, __pyx_k_SVD_desired_part_of_spectrum_LA, sizeof(__pyx_k_SVD_desired_part_of_spectrum_LA), 0, 0, 1, 0},
  {&__pyx_kp_s_SVD_error_type_to_assess_accura, __pyx_k_SVD_error_type_to_assess_accura, sizeof(__pyx_k_SVD_error_type_to_assess_accura), 0, 0, 1, 0},
  {&__pyx_kp_s_SVD_problem_type_STANDARD_Stand, __pyx_k_SVD_problem_type_STANDARD_Stand, sizeof(__pyx_k_SVD_problem_type_STANDARD_Stand), 0, 0, 1, 0},
  {&__pyx_kp_s_SVD_stopping_test_BASIC_Default, __pyx_k_SVD_stopping_test_BASIC_Default, sizeof(__pyx_k_SVD_stopping_test_BASIC_Default), 0, 0, 1, 0},
  {&__pyx_kp_s_SVD_types_CROSS_Eigenproblem_wi, __pyx_k_SVD_types_CROSS_Eigenproblem_wi, sizeof(__pyx_k_SVD_types_CROSS_Eigenproblem_wi), 0, 0, 1, 0},
  {&__pyx_n_s_SVEC, __pyx_k_SVEC, sizeof(__pyx_k_SVEC), 0, 0, 1, 1},
  {&__pyx_n_s_SVQB, __pyx_k_SVQB, sizeof(__pyx_k_SVQB), 0, 0, 1, 1},
  {&__pyx_n_s_SYNCHRONIZED, __pyx_k_SYNCHRONIZED, sizeof(__pyx_k_SYNCHRONIZED), 0, 0, 1, 1},
  {&__pyx_kp_u_Scalable_Library_for_Eigenvalue, __pyx_k_Scalable_Library_for_Eigenvalue, sizeof(__pyx_k_Scalable_Library_for_Eigenvalue), 0, 1, 0, 0},
  {&__pyx_n_s_ScalarType, __pyx_k_ScalarType, sizeof(__pyx_k_ScalarType), 0, 0, 1, 1},
  {&__pyx_n_s_Scale, __pyx_k_Scale, sizeof(__pyx_k_Scale), 0, 0, 1, 1},
  {&__pyx_n_s_StateType, __pyx_k_StateType, sizeof(__pyx_k_StateType), 0, 0, 1, 1},
  {&__pyx_n_s_Stop, __pyx_k_Stop, sizeof(__pyx_k_Stop), 0, 0, 1, 1},
  {&__pyx_n_s_Sys, __pyx_k_Sys, sizeof(__pyx_k_Sys), 0, 0, 1, 1},
  {&__pyx_n_s_T, __pyx_k_T, sizeof(__pyx_k_T), 0, 0, 1, 1},
  {&__pyx_n_s_TARGET_IMAGINARY, __pyx_k_TARGET_IMAGINARY, sizeof(__pyx_k_TARGET_IMAGINARY), 0, 0, 1, 1},
  {&__pyx_n_s_TARGET_MAGNITUDE, __pyx_k_TARGET_MAGNITUDE, sizeof(__pyx_k_TARGET_MAGNITUDE), 0, 0, 1, 1},
  {&__pyx_n_s_TARGET_REAL, __pyx_k_TARGET_REAL, sizeof(__pyx_k_TARGET_REAL), 0, 0, 1, 1},
  {&__pyx_n_s_TENSOR, __pyx_k_TENSOR, sizeof(__pyx_k_TENSOR), 0, 0, 1, 1},
  {&__pyx_n_s_TOAR, __pyx_k_TOAR, sizeof(__pyx_k_TOAR), 0, 0, 1, 1},
  {&__pyx_n_s_TRAPEZOIDAL, __pyx_k_TRAPEZOIDAL, sizeof(__pyx_k_TRAPEZOIDAL), 0, 0, 1, 1},
  {&__pyx_n_s_TRLAN, __pyx_k_TRLAN, sizeof(__pyx_k_TRLAN), 0, 0, 1, 1},
  {&__pyx_n_s_TRLANCZOS, __pyx_k_TRLANCZOS, sizeof(__pyx_k_TRLANCZOS), 0, 0, 1, 1},
  {&__pyx_n_s_TRLanczosGBidiag, __pyx_k_TRLanczosGBidiag, sizeof(__pyx_k_TRLanczosGBidiag), 0, 0, 1, 1},
  {&__pyx_n_s_TRUNCATED, __pyx_k_TRUNCATED, sizeof(__pyx_k_TRUNCATED), 0, 0, 1, 1},
  {&__pyx_n_s_TSQR, __pyx_k_TSQR, sizeof(__pyx_k_TSQR), 0, 0, 1, 1},
  {&__pyx_n_s_TSQRCHOL, __pyx_k_TSQRCHOL, sizeof(__pyx_k_TSQRCHOL), 0, 0, 1, 1},
  {&__pyx_n_s_TWOSIDE, __pyx_k_TWOSIDE, sizeof(__pyx_k_TWOSIDE), 0, 0, 1, 1},
  {&__pyx_kp_s_To_refer_to_one_of_the_matrices, __pyx_k_To_refer_to_one_of_the_matrices, sizeof(__pyx_k_To_refer_to_one_of_the_matrices), 0, 0, 1, 0},
  {&__pyx_n_s_Type, __pyx_k_Type, sizeof(__pyx_k_Type), 0, 0, 1, 1},
  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
  {&__pyx_n_s_U, __pyx_k_U, sizeof(__pyx_k_U), 0, 0, 1, 1},
  {&__pyx_n_s_UPPER, __pyx_k_UPPER, sizeof(__pyx_k_UPPER), 0, 0, 1, 1},
  {&__pyx_n_s_USER, __pyx_k_USER, sizeof(__pyx_k_USER), 0, 0, 1, 1},
  {&__pyx_n_s_V, __pyx_k_V, sizeof(__pyx_k_V), 0, 0, 1, 1},
  {&__pyx_n_s_VECS, __pyx_k_VECS, sizeof(__pyx_k_VECS), 0, 0, 1, 1},
  {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
  {&__pyx_n_s_Vi, __pyx_k_Vi, sizeof(__pyx_k_Vi), 0, 0, 1, 1},
  {&__pyx_n_s_Vr, __pyx_k_Vr, sizeof(__pyx_k_Vr), 0, 0, 1, 1},
  {&__pyx_n_s_W, __pyx_k_W, sizeof(__pyx_k_W), 0, 0, 1, 1},
  {&__pyx_n_s_WILKINSON, __pyx_k_WILKINSON, sizeof(__pyx_k_WILKINSON), 0, 0, 1, 1},
  {&__pyx_n_s_Which, __pyx_k_Which, sizeof(__pyx_k_Which), 0, 0, 1, 1},
  {&__pyx_n_s_Wi, __pyx_k_Wi, sizeof(__pyx_k_Wi), 0, 0, 1, 1},
  {&__pyx_n_s_Wr, __pyx_k_Wr, sizeof(__pyx_k_Wr), 0, 0, 1, 1},
  {&__pyx_n_s_X, __pyx_k_X, sizeof(__pyx_k_X), 0, 0, 1, 1},
  {&__pyx_n_s_Y, __pyx_k_Y, sizeof(__pyx_k_Y), 0, 0, 1, 1},
  {&__pyx_n_s_Z, __pyx_k_Z, sizeof(__pyx_k_Z), 0, 0, 1, 1},
  {&__pyx_kp_s__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 1, 0},
  {&__pyx_kp_s__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 1, 0},
  {&__pyx_n_s_a, __pyx_k_a, sizeof(__pyx_k_a), 0, 0, 1, 1},
  {&__pyx_n_s_alpha, __pyx_k_alpha, sizeof(__pyx_k_alpha), 0, 0, 1, 1},
  {&__pyx_n_s_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1},
  {&__pyx_n_s_arbitrary, __pyx_k_arbitrary, sizeof(__pyx_k_arbitrary), 0, 0, 1, 1},
  {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1},
  {&__pyx_n_s_author, __pyx_k_author, sizeof(__pyx_k_author), 0, 0, 1, 1},
  {&__pyx_n_s_authorinfo, __pyx_k_authorinfo, sizeof(__pyx_k_authorinfo), 0, 0, 1, 1},
  {&__pyx_n_s_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1},
  {&__pyx_n_s_balance, __pyx_k_balance, sizeof(__pyx_k_balance), 0, 0, 1, 1},
  {&__pyx_n_s_basis, __pyx_k_basis, sizeof(__pyx_k_basis), 0, 0, 1, 1},
  {&__pyx_n_s_beta, __pyx_k_beta, sizeof(__pyx_k_beta), 0, 0, 1, 1},
  {&__pyx_n_s_bidiag, __pyx_k_bidiag, sizeof(__pyx_k_bidiag), 0, 0, 1, 1},
  {&__pyx_n_s_block, __pyx_k_block, sizeof(__pyx_k_block), 0, 0, 1, 1},
  {&__pyx_n_s_blsize, __pyx_k_blsize, sizeof(__pyx_k_blsize), 0, 0, 1, 1},
  {&__pyx_n_s_borth, __pyx_k_borth, sizeof(__pyx_k_borth), 0, 0, 1, 1},
  {&__pyx_n_s_bs, __pyx_k_bs, sizeof(__pyx_k_bs), 0, 0, 1, 1},
  {&__pyx_n_s_bsmax, __pyx_k_bsmax, sizeof(__pyx_k_bsmax), 0, 0, 1, 1},
  {&__pyx_n_s_bv, __pyx_k_bv, sizeof(__pyx_k_bv), 0, 0, 1, 1},
  {&__pyx_n_s_bv_type, __pyx_k_bv_type, sizeof(__pyx_k_bv_type), 0, 0, 1, 1},
  {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1},
  {&__pyx_n_s_cct, __pyx_k_cct, sizeof(__pyx_k_cct), 0, 0, 1, 1},
  {&__pyx_n_s_center, __pyx_k_center, sizeof(__pyx_k_center), 0, 0, 1, 1},
  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
  {&__pyx_n_s_comb, __pyx_k_comb, sizeof(__pyx_k_comb), 0, 0, 1, 1},
  {&__pyx_n_s_comm, __pyx_k_comm, sizeof(__pyx_k_comm), 0, 0, 1, 1},
  {&__pyx_n_s_comp, __pyx_k_comp, sizeof(__pyx_k_comp), 0, 0, 1, 1},
  {&__pyx_n_s_comparison, __pyx_k_comparison, sizeof(__pyx_k_comparison), 0, 0, 1, 1},
  {&__pyx_n_s_condn, __pyx_k_condn, sizeof(__pyx_k_condn), 0, 0, 1, 1},
  {&__pyx_n_s_constant, __pyx_k_constant, sizeof(__pyx_k_constant), 0, 0, 1, 1},
  {&__pyx_n_s_conv, __pyx_k_conv, sizeof(__pyx_k_conv), 0, 0, 1, 1},
  {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1},
  {&__pyx_n_s_createDense, __pyx_k_createDense, sizeof(__pyx_k_createDense), 0, 0, 1, 1},
  {&__pyx_n_s_createVecs, __pyx_k_createVecs, sizeof(__pyx_k_createVecs), 0, 0, 1, 1},
  {&__pyx_n_s_cutoff, __pyx_k_cutoff, sizeof(__pyx_k_cutoff), 0, 0, 1, 1},
  {&__pyx_n_s_d, __pyx_k_d, sizeof(__pyx_k_d), 0, 0, 1, 1},
  {&__pyx_n_s_date, __pyx_k_date, sizeof(__pyx_k_date), 0, 0, 1, 1},
  {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1},
  {&__pyx_n_s_deftol, __pyx_k_deftol, sizeof(__pyx_k_deftol), 0, 0, 1, 1},
  {&__pyx_n_s_deg, __pyx_k_deg, sizeof(__pyx_k_deg), 0, 0, 1, 1},
  {&__pyx_n_s_delayed, __pyx_k_delayed, sizeof(__pyx_k_delayed), 0, 0, 1, 1},
  {&__pyx_n_s_delta, __pyx_k_delta, sizeof(__pyx_k_delta), 0, 0, 1, 1},
  {&__pyx_n_s_detect, __pyx_k_detect, sizeof(__pyx_k_detect), 0, 0, 1, 1},
  {&__pyx_n_s_devel, __pyx_k_devel, sizeof(__pyx_k_devel), 0, 0, 1, 1},
  {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1},
  {&__pyx_n_s_doubleexp, __pyx_k_doubleexp, sizeof(__pyx_k_doubleexp), 0, 0, 1, 1},
  {&__pyx_n_s_ds, __pyx_k_ds, sizeof(__pyx_k_ds), 0, 0, 1, 1},
  {&__pyx_n_s_ds_type, __pyx_k_ds_type, sizeof(__pyx_k_ds_type), 0, 0, 1, 1},
  {&__pyx_n_s_duplicate, __pyx_k_duplicate, sizeof(__pyx_k_duplicate), 0, 0, 1, 1},
  {&__pyx_n_s_e, __pyx_k_e, sizeof(__pyx_k_e), 0, 0, 1, 1},
  {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1},
  {&__pyx_n_s_end_ang, __pyx_k_end_ang, sizeof(__pyx_k_end_ang), 0, 0, 1, 1},
  {&__pyx_n_s_eps, __pyx_k_eps, sizeof(__pyx_k_eps), 0, 0, 1, 1},
  {&__pyx_n_s_eps_type, __pyx_k_eps_type, sizeof(__pyx_k_eps_type), 0, 0, 1, 1},
  {&__pyx_n_s_eta, __pyx_k_eta, sizeof(__pyx_k_eta), 0, 0, 1, 1},
  {&__pyx_n_s_etype, __pyx_k_etype, sizeof(__pyx_k_etype), 0, 0, 1, 1},
  {&__pyx_n_s_ext, __pyx_k_ext, sizeof(__pyx_k_ext), 0, 0, 1, 1},
  {&__pyx_n_s_extract, __pyx_k_extract, sizeof(__pyx_k_extract), 0, 0, 1, 1},
  {&__pyx_n_s_extraction, __pyx_k_extraction, sizeof(__pyx_k_extraction), 0, 0, 1, 1},
  {&__pyx_n_s_f, __pyx_k_f, sizeof(__pyx_k_f), 0, 0, 1, 1},
  {&__pyx_n_s_f1, __pyx_k_f1, sizeof(__pyx_k_f1), 0, 0, 1, 1},
  {&__pyx_n_s_f2, __pyx_k_f2, sizeof(__pyx_k_f2), 0, 0, 1, 1},
  {&__pyx_n_s_finalize, __pyx_k_finalize, sizeof(__pyx_k_finalize), 0, 0, 1, 1},
  {&__pyx_n_s_fix, __pyx_k_fix, sizeof(__pyx_k_fix), 0, 0, 1, 1},
  {&__pyx_n_s_flag, __pyx_k_flag, sizeof(__pyx_k_flag), 0, 0, 1, 1},
  {&__pyx_n_s_flg, __pyx_k_flg, sizeof(__pyx_k_flg), 0, 0, 1, 1},
  {&__pyx_n_s_fn, __pyx_k_fn, sizeof(__pyx_k_fn), 0, 0, 1, 1},
  {&__pyx_n_s_fn_type, __pyx_k_fn_type, sizeof(__pyx_k_fn_type), 0, 0, 1, 1},
  {&__pyx_n_s_fullbasis, __pyx_k_fullbasis, sizeof(__pyx_k_fullbasis), 0, 0, 1, 1},
  {&__pyx_n_s_function, __pyx_k_function, sizeof(__pyx_k_function), 0, 0, 1, 1},
  {&__pyx_n_s_getActiveColumns, __pyx_k_getActiveColumns, sizeof(__pyx_k_getActiveColumns), 0, 0, 1, 1},
  {&__pyx_n_s_getBV, __pyx_k_getBV, sizeof(__pyx_k_getBV), 0, 0, 1, 1},
  {&__pyx_n_s_getBlockSize, __pyx_k_getBlockSize, sizeof(__pyx_k_getBlockSize), 0, 0, 1, 1},
  {&__pyx_n_s_getCompact, __pyx_k_getCompact, sizeof(__pyx_k_getCompact), 0, 0, 1, 1},
  {&__pyx_n_s_getComplement, __pyx_k_getComplement, sizeof(__pyx_k_getComplement), 0, 0, 1, 1},
  {&__pyx_n_s_getDS, __pyx_k_getDS, sizeof(__pyx_k_getDS), 0, 0, 1, 1},
  {&__pyx_n_s_getExtraRow, __pyx_k_getExtraRow, sizeof(__pyx_k_getExtraRow), 0, 0, 1, 1},
  {&__pyx_n_s_getExtract, __pyx_k_getExtract, sizeof(__pyx_k_getExtract), 0, 0, 1, 1},
  {&__pyx_n_s_getExtraction, __pyx_k_getExtraction, sizeof(__pyx_k_getExtraction), 0, 0, 1, 1},
  {&__pyx_n_s_getFN, __pyx_k_getFN, sizeof(__pyx_k_getFN), 0, 0, 1, 1},
  {&__pyx_n_s_getKSP, __pyx_k_getKSP, sizeof(__pyx_k_getKSP), 0, 0, 1, 1},
  {&__pyx_n_s_getMatMode, __pyx_k_getMatMode, sizeof(__pyx_k_getMatMode), 0, 0, 1, 1},
  {&__pyx_n_s_getMatStructure, __pyx_k_getMatStructure, sizeof(__pyx_k_getMatStructure), 0, 0, 1, 1},
  {&__pyx_n_s_getMethod, __pyx_k_getMethod, sizeof(__pyx_k_getMethod), 0, 0, 1, 1},
  {&__pyx_n_s_getParallel, __pyx_k_getParallel, sizeof(__pyx_k_getParallel), 0, 0, 1, 1},
  {&__pyx_n_s_getProblemType, __pyx_k_getProblemType, sizeof(__pyx_k_getProblemType), 0, 0, 1, 1},
  {&__pyx_n_s_getPurify, __pyx_k_getPurify, sizeof(__pyx_k_getPurify), 0, 0, 1, 1},
  {&__pyx_n_s_getRG, __pyx_k_getRG, sizeof(__pyx_k_getRG), 0, 0, 1, 1},
  {&__pyx_n_s_getRefined, __pyx_k_getRefined, sizeof(__pyx_k_getRefined), 0, 0, 1, 1},
  {&__pyx_n_s_getST, __pyx_k_getST, sizeof(__pyx_k_getST), 0, 0, 1, 1},
  {&__pyx_n_s_getScale, __pyx_k_getScale, sizeof(__pyx_k_getScale), 0, 0, 1, 1},
  {&__pyx_n_s_getShift, __pyx_k_getShift, sizeof(__pyx_k_getShift), 0, 0, 1, 1},
  {&__pyx_n_s_getState, __pyx_k_getState, sizeof(__pyx_k_getState), 0, 0, 1, 1},
  {&__pyx_n_s_getTarget, __pyx_k_getTarget, sizeof(__pyx_k_getTarget), 0, 0, 1, 1},
  {&__pyx_n_s_getTolerances, __pyx_k_getTolerances, sizeof(__pyx_k_getTolerances), 0, 0, 1, 1},
  {&__pyx_n_s_getTrackAll, __pyx_k_getTrackAll, sizeof(__pyx_k_getTrackAll), 0, 0, 1, 1},
  {&__pyx_n_s_getTransform, __pyx_k_getTransform, sizeof(__pyx_k_getTransform), 0, 0, 1, 1},
  {&__pyx_n_s_getTransposeMode, __pyx_k_getTransposeMode, sizeof(__pyx_k_getTransposeMode), 0, 0, 1, 1},
  {&__pyx_n_s_getTrueResidual, __pyx_k_getTrueResidual, sizeof(__pyx_k_getTrueResidual), 0, 0, 1, 1},
  {&__pyx_n_s_getTwoSided, __pyx_k_getTwoSided, sizeof(__pyx_k_getTwoSided), 0, 0, 1, 1},
  {&__pyx_n_s_getVersion, __pyx_k_getVersion, sizeof(__pyx_k_getVersion), 0, 0, 1, 1},
  {&__pyx_n_s_getVersionInfo, __pyx_k_getVersionInfo, sizeof(__pyx_k_getVersionInfo), 0, 0, 1, 1},
  {&__pyx_n_s_getWhichEigenpairs, __pyx_k_getWhichEigenpairs, sizeof(__pyx_k_getWhichEigenpairs), 0, 0, 1, 1},
  {&__pyx_n_s_getWhichSingularTriplets, __pyx_k_getWhichSingularTriplets, sizeof(__pyx_k_getWhichSingularTriplets), 0, 0, 1, 1},
  {&__pyx_n_s_globalup, __pyx_k_globalup, sizeof(__pyx_k_globalup), 0, 0, 1, 1},
  {&__pyx_n_s_hasExternalPackage, __pyx_k_hasExternalPackage, sizeof(__pyx_k_hasExternalPackage), 0, 0, 1, 1},
  {&__pyx_n_s_herm, __pyx_k_herm, sizeof(__pyx_k_herm), 0, 0, 1, 1},
  {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1},
  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
  {&__pyx_n_s_indef, __pyx_k_indef, sizeof(__pyx_k_indef), 0, 0, 1, 1},
  {&__pyx_n_s_initialize, __pyx_k_initialize, sizeof(__pyx_k_initialize), 0, 0, 1, 1},
  {&__pyx_n_s_initialsize, __pyx_k_initialsize, sizeof(__pyx_k_initialsize), 0, 0, 1, 1},
  {&__pyx_n_s_inner, __pyx_k_inner, sizeof(__pyx_k_inner), 0, 0, 1, 1},
  {&__pyx_n_s_inta, __pyx_k_inta, sizeof(__pyx_k_inta), 0, 0, 1, 1},
  {&__pyx_n_s_intb, __pyx_k_intb, sizeof(__pyx_k_intb), 0, 0, 1, 1},
  {&__pyx_n_s_ip, __pyx_k_ip, sizeof(__pyx_k_ip), 0, 0, 1, 1},
  {&__pyx_n_s_isFinalized, __pyx_k_isFinalized, sizeof(__pyx_k_isFinalized), 0, 0, 1, 1},
  {&__pyx_n_s_isInitialized, __pyx_k_isInitialized, sizeof(__pyx_k_isInitialized), 0, 0, 1, 1},
  {&__pyx_n_s_iterations, __pyx_k_iterations, sizeof(__pyx_k_iterations), 0, 0, 1, 1},
  {&__pyx_n_s_its, __pyx_k_its, sizeof(__pyx_k_its), 0, 0, 1, 1},
  {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1},
  {&__pyx_n_s_jacobian, __pyx_k_jacobian, sizeof(__pyx_k_jacobian), 0, 0, 1, 1},
  {&__pyx_n_s_k, __pyx_k_k, sizeof(__pyx_k_k), 0, 0, 1, 1},
  {&__pyx_n_s_kargs, __pyx_k_kargs, sizeof(__pyx_k_kargs), 0, 0, 1, 1},
  {&__pyx_n_s_keep, __pyx_k_keep, sizeof(__pyx_k_keep), 0, 0, 1, 1},
  {&__pyx_n_s_krylovstart, __pyx_k_krylovstart, sizeof(__pyx_k_krylovstart), 0, 0, 1, 1},
  {&__pyx_n_s_ksp, __pyx_k_ksp, sizeof(__pyx_k_ksp), 0, 0, 1, 1},
  {&__pyx_n_s_l, __pyx_k_l, sizeof(__pyx_k_l), 0, 0, 1, 1},
  {&__pyx_n_s_lag, __pyx_k_lag, sizeof(__pyx_k_lag), 0, 0, 1, 1},
  {&__pyx_n_s_lbda, __pyx_k_lbda, sizeof(__pyx_k_lbda), 0, 0, 1, 1},
  {&__pyx_n_s_ld, __pyx_k_ld, sizeof(__pyx_k_ld), 0, 0, 1, 1},
  {&__pyx_n_s_left, __pyx_k_left, sizeof(__pyx_k_left), 0, 0, 1, 1},
  {&__pyx_kp_s_local_and_global_sizes_cannot_be, __pyx_k_local_and_global_sizes_cannot_be, sizeof(__pyx_k_local_and_global_sizes_cannot_be), 0, 0, 1, 0},
  {&__pyx_n_s_lock, __pyx_k_lock, sizeof(__pyx_k_lock), 0, 0, 1, 1},
  {&__pyx_n_s_m, __pyx_k_m, sizeof(__pyx_k_m), 0, 0, 1, 1},
  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
  {&__pyx_n_s_major, __pyx_k_major, sizeof(__pyx_k_major), 0, 0, 1, 1},
  {&__pyx_n_s_mat, __pyx_k_mat, sizeof(__pyx_k_mat), 0, 0, 1, 1},
  {&__pyx_n_s_matname, __pyx_k_matname, sizeof(__pyx_k_matname), 0, 0, 1, 1},
  {&__pyx_n_s_max_it, __pyx_k_max_it, sizeof(__pyx_k_max_it), 0, 0, 1, 1},
  {&__pyx_n_s_maxit, __pyx_k_maxit, sizeof(__pyx_k_maxit), 0, 0, 1, 1},
  {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1},
  {&__pyx_n_s_meth, __pyx_k_meth, sizeof(__pyx_k_meth), 0, 0, 1, 1},
  {&__pyx_n_s_method, __pyx_k_method, sizeof(__pyx_k_method), 0, 0, 1, 1},
  {&__pyx_n_s_mfn_type, __pyx_k_mfn_type, sizeof(__pyx_k_mfn_type), 0, 0, 1, 1},
  {&__pyx_n_s_minor, __pyx_k_minor, sizeof(__pyx_k_minor), 0, 0, 1, 1},
  {&__pyx_n_s_minv, __pyx_k_minv, sizeof(__pyx_k_minv), 0, 0, 1, 1},
  {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1},
  {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1},
  {&__pyx_n_s_monitor, __pyx_k_monitor, sizeof(__pyx_k_monitor), 0, 0, 1, 1},
  {&__pyx_n_s_mpd, __pyx_k_mpd, sizeof(__pyx_k_mpd), 0, 0, 1, 1},
  {&__pyx_n_s_ms, __pyx_k_ms, sizeof(__pyx_k_ms), 0, 0, 1, 1},
  {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1},
  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
  {&__pyx_n_s_nc, __pyx_k_nc, sizeof(__pyx_k_nc), 0, 0, 1, 1},
  {&__pyx_n_s_ncv, __pyx_k_ncv, sizeof(__pyx_k_ncv), 0, 0, 1, 1},
  {&__pyx_n_s_nep_type, __pyx_k_nep_type, sizeof(__pyx_k_nep_type), 0, 0, 1, 1},
  {&__pyx_n_s_nev, __pyx_k_nev, sizeof(__pyx_k_nev), 0, 0, 1, 1},
  {&__pyx_n_s_norm_type, __pyx_k_norm_type, sizeof(__pyx_k_norm_type), 0, 0, 1, 1},
  {&__pyx_n_s_npart, __pyx_k_npart, sizeof(__pyx_k_npart), 0, 0, 1, 1},
  {&__pyx_n_s_nrest, __pyx_k_nrest, sizeof(__pyx_k_nrest), 0, 0, 1, 1},
  {&__pyx_n_s_nsv, __pyx_k_nsv, sizeof(__pyx_k_nsv), 0, 0, 1, 1},
  {&__pyx_n_s_object, __pyx_k_object, sizeof(__pyx_k_object), 0, 0, 1, 1},
  {&__pyx_n_s_omega, __pyx_k_omega, sizeof(__pyx_k_omega), 0, 0, 1, 1},
  {&__pyx_n_s_op, __pyx_k_op, sizeof(__pyx_k_op), 0, 0, 1, 1},
  {&__pyx_n_s_operators, __pyx_k_operators, sizeof(__pyx_k_operators), 0, 0, 1, 1},
  {&__pyx_n_s_orth, __pyx_k_orth, sizeof(__pyx_k_orth), 0, 0, 1, 1},
  {&__pyx_n_s_otype, __pyx_k_otype, sizeof(__pyx_k_otype), 0, 0, 1, 1},
  {&__pyx_n_s_p, __pyx_k_p, sizeof(__pyx_k_p), 0, 0, 1, 1},
  {&__pyx_n_s_p_mem, __pyx_k_p_mem, sizeof(__pyx_k_p_mem), 0, 0, 1, 1},
  {&__pyx_n_s_package, __pyx_k_package, sizeof(__pyx_k_package), 0, 0, 1, 1},
  {&__pyx_n_s_pbc, __pyx_k_pbc, sizeof(__pyx_k_pbc), 0, 0, 1, 1},
  {&__pyx_n_s_pep, __pyx_k_pep, sizeof(__pyx_k_pep), 0, 0, 1, 1},
  {&__pyx_n_s_pep_type, __pyx_k_pep_type, sizeof(__pyx_k_pep_type), 0, 0, 1, 1},
  {&__pyx_n_s_petsc4py_PETSc, __pyx_k_petsc4py_PETSc, sizeof(__pyx_k_petsc4py_PETSc), 0, 0, 1, 1},
  {&__pyx_n_s_plusk, __pyx_k_plusk, sizeof(__pyx_k_plusk), 0, 0, 1, 1},
  {&__pyx_n_s_pmode, __pyx_k_pmode, sizeof(__pyx_k_pmode), 0, 0, 1, 1},
  {&__pyx_n_s_prefix, __pyx_k_prefix, sizeof(__pyx_k_prefix), 0, 0, 1, 1},
  {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1},
  {&__pyx_n_s_problem_type, __pyx_k_problem_type, sizeof(__pyx_k_problem_type), 0, 0, 1, 1},
  {&__pyx_n_s_proj, __pyx_k_proj, sizeof(__pyx_k_proj), 0, 0, 1, 1},
  {&__pyx_n_s_purify, __pyx_k_purify, sizeof(__pyx_k_purify), 0, 0, 1, 1},
  {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1},
  {&__pyx_n_s_q, __pyx_k_q, sizeof(__pyx_k_q), 0, 0, 1, 1},
  {&__pyx_n_s_quad, __pyx_k_quad, sizeof(__pyx_k_quad), 0, 0, 1, 1},
  {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1},
  {&__pyx_n_s_r, __pyx_k_r, sizeof(__pyx_k_r), 0, 0, 1, 1},
  {&__pyx_n_s_radius, __pyx_k_radius, sizeof(__pyx_k_radius), 0, 0, 1, 1},
  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
  {&__pyx_n_s_ready, __pyx_k_ready, sizeof(__pyx_k_ready), 0, 0, 1, 1},
  {&__pyx_n_s_realmats, __pyx_k_realmats, sizeof(__pyx_k_realmats), 0, 0, 1, 1},
  {&__pyx_n_s_ref, __pyx_k_ref, sizeof(__pyx_k_ref), 0, 0, 1, 1},
  {&__pyx_n_s_refine, __pyx_k_refine, sizeof(__pyx_k_refine), 0, 0, 1, 1},
  {&__pyx_n_s_release, __pyx_k_release, sizeof(__pyx_k_release), 0, 0, 1, 1},
  {&__pyx_n_s_reorthog, __pyx_k_reorthog, sizeof(__pyx_k_reorthog), 0, 0, 1, 1},
  {&__pyx_n_s_replace, __pyx_k_replace, sizeof(__pyx_k_replace), 0, 0, 1, 1},
  {&__pyx_n_s_restart, __pyx_k_restart, sizeof(__pyx_k_restart), 0, 0, 1, 1},
  {&__pyx_n_s_result, __pyx_k_result, sizeof(__pyx_k_result), 0, 0, 1, 1},
  {&__pyx_n_s_rg, __pyx_k_rg, sizeof(__pyx_k_rg), 0, 0, 1, 1},
  {&__pyx_n_s_rg_type, __pyx_k_rg_type, sizeof(__pyx_k_rg_type), 0, 0, 1, 1},
  {&__pyx_n_s_right, __pyx_k_right, sizeof(__pyx_k_right), 0, 0, 1, 1},
  {&__pyx_n_s_rkc, __pyx_k_rkc, sizeof(__pyx_k_rkc), 0, 0, 1, 1},
  {&__pyx_n_s_rkl, __pyx_k_rkl, sizeof(__pyx_k_rkl), 0, 0, 1, 1},
  {&__pyx_n_s_rnd, __pyx_k_rnd, sizeof(__pyx_k_rnd), 0, 0, 1, 1},
  {&__pyx_n_s_s, __pyx_k_s, sizeof(__pyx_k_s), 0, 0, 1, 1},
  {&__pyx_n_s_scale, __pyx_k_scale, sizeof(__pyx_k_scale), 0, 0, 1, 1},
  {&__pyx_n_s_scheme, __pyx_k_scheme, sizeof(__pyx_k_scheme), 0, 0, 1, 1},
  {&__pyx_n_s_setBV, __pyx_k_setBV, sizeof(__pyx_k_setBV), 0, 0, 1, 1},
  {&__pyx_n_s_setBlockSize, __pyx_k_setBlockSize, sizeof(__pyx_k_setBlockSize), 0, 0, 1, 1},
  {&__pyx_n_s_setCompact, __pyx_k_setCompact, sizeof(__pyx_k_setCompact), 0, 0, 1, 1},
  {&__pyx_n_s_setComplement, __pyx_k_setComplement, sizeof(__pyx_k_setComplement), 0, 0, 1, 1},
  {&__pyx_n_s_setDS, __pyx_k_setDS, sizeof(__pyx_k_setDS), 0, 0, 1, 1},
  {&__pyx_n_s_setExtraRow, __pyx_k_setExtraRow, sizeof(__pyx_k_setExtraRow), 0, 0, 1, 1},
  {&__pyx_n_s_setExtract, __pyx_k_setExtract, sizeof(__pyx_k_setExtract), 0, 0, 1, 1},
  {&__pyx_n_s_setExtraction, __pyx_k_setExtraction, sizeof(__pyx_k_setExtraction), 0, 0, 1, 1},
  {&__pyx_n_s_setKSP, __pyx_k_setKSP, sizeof(__pyx_k_setKSP), 0, 0, 1, 1},
  {&__pyx_n_s_setMatMode, __pyx_k_setMatMode, sizeof(__pyx_k_setMatMode), 0, 0, 1, 1},
  {&__pyx_n_s_setMatStructure, __pyx_k_setMatStructure, sizeof(__pyx_k_setMatStructure), 0, 0, 1, 1},
  {&__pyx_n_s_setMethod, __pyx_k_setMethod, sizeof(__pyx_k_setMethod), 0, 0, 1, 1},
  {&__pyx_n_s_setOperator, __pyx_k_setOperator, sizeof(__pyx_k_setOperator), 0, 0, 1, 1},
  {&__pyx_n_s_setOperators, __pyx_k_setOperators, sizeof(__pyx_k_setOperators), 0, 0, 1, 1},
  {&__pyx_n_s_setOrthogonalization, __pyx_k_setOrthogonalization, sizeof(__pyx_k_setOrthogonalization), 0, 0, 1, 1},
  {&__pyx_n_s_setParallel, __pyx_k_setParallel, sizeof(__pyx_k_setParallel), 0, 0, 1, 1},
  {&__pyx_n_s_setProblemType, __pyx_k_setProblemType, sizeof(__pyx_k_setProblemType), 0, 0, 1, 1},
  {&__pyx_n_s_setPurify, __pyx_k_setPurify, sizeof(__pyx_k_setPurify), 0, 0, 1, 1},
  {&__pyx_n_s_setRG, __pyx_k_setRG, sizeof(__pyx_k_setRG), 0, 0, 1, 1},
  {&__pyx_n_s_setRefined, __pyx_k_setRefined, sizeof(__pyx_k_setRefined), 0, 0, 1, 1},
  {&__pyx_n_s_setST, __pyx_k_setST, sizeof(__pyx_k_setST), 0, 0, 1, 1},
  {&__pyx_n_s_setScale, __pyx_k_setScale, sizeof(__pyx_k_setScale), 0, 0, 1, 1},
  {&__pyx_n_s_setShift, __pyx_k_setShift, sizeof(__pyx_k_setShift), 0, 0, 1, 1},
  {&__pyx_n_s_setState, __pyx_k_setState, sizeof(__pyx_k_setState), 0, 0, 1, 1},
  {&__pyx_n_s_setTarget, __pyx_k_setTarget, sizeof(__pyx_k_setTarget), 0, 0, 1, 1},
  {&__pyx_n_s_setTolerances, __pyx_k_setTolerances, sizeof(__pyx_k_setTolerances), 0, 0, 1, 1},
  {&__pyx_n_s_setTrackAll, __pyx_k_setTrackAll, sizeof(__pyx_k_setTrackAll), 0, 0, 1, 1},
  {&__pyx_n_s_setTransform, __pyx_k_setTransform, sizeof(__pyx_k_setTransform), 0, 0, 1, 1},
  {&__pyx_n_s_setTransposeMode, __pyx_k_setTransposeMode, sizeof(__pyx_k_setTransposeMode), 0, 0, 1, 1},
  {&__pyx_n_s_setTrueResidual, __pyx_k_setTrueResidual, sizeof(__pyx_k_setTrueResidual), 0, 0, 1, 1},
  {&__pyx_n_s_setTwoSided, __pyx_k_setTwoSided, sizeof(__pyx_k_setTwoSided), 0, 0, 1, 1},
  {&__pyx_n_s_setUp, __pyx_k_setUp, sizeof(__pyx_k_setUp), 0, 0, 1, 1},
  {&__pyx_n_s_setWhichEigenpairs, __pyx_k_setWhichEigenpairs, sizeof(__pyx_k_setWhichEigenpairs), 0, 0, 1, 1},
  {&__pyx_n_s_setWhichSingularTriplets, __pyx_k_setWhichSingularTriplets, sizeof(__pyx_k_setWhichSingularTriplets), 0, 0, 1, 1},
  {&__pyx_n_s_sfactor, __pyx_k_sfactor, sizeof(__pyx_k_sfactor), 0, 0, 1, 1},
  {&__pyx_n_s_shift, __pyx_k_shift, sizeof(__pyx_k_shift), 0, 0, 1, 1},
  {&__pyx_n_s_shifts, __pyx_k_shifts, sizeof(__pyx_k_shifts), 0, 0, 1, 1},
  {&__pyx_n_s_sizes, __pyx_k_sizes, sizeof(__pyx_k_sizes), 0, 0, 1, 1},
  {&__pyx_n_s_slepc4py_SLEPc, __pyx_k_slepc4py_SLEPc, sizeof(__pyx_k_slepc4py_SLEPc), 0, 0, 1, 1},
  {&__pyx_n_s_space, __pyx_k_space, sizeof(__pyx_k_space), 0, 0, 1, 1},
  {&__pyx_n_s_spaceleft, __pyx_k_spaceleft, sizeof(__pyx_k_spaceleft), 0, 0, 1, 1},
  {&__pyx_n_s_spaceright, __pyx_k_spaceright, sizeof(__pyx_k_spaceright), 0, 0, 1, 1},
  {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1},
  {&__pyx_n_s_spur, __pyx_k_spur, sizeof(__pyx_k_spur), 0, 0, 1, 1},
  {&__pyx_n_s_st, __pyx_k_st, sizeof(__pyx_k_st), 0, 0, 1, 1},
  {&__pyx_n_s_st_type, __pyx_k_st_type, sizeof(__pyx_k_st_type), 0, 0, 1, 1},
  {&__pyx_n_s_start_ang, __pyx_k_start_ang, sizeof(__pyx_k_start_ang), 0, 0, 1, 1},
  {&__pyx_n_s_state, __pyx_k_state, sizeof(__pyx_k_state), 0, 0, 1, 1},
  {&__pyx_n_s_stopping, __pyx_k_stopping, sizeof(__pyx_k_stopping), 0, 0, 1, 1},
  {&__pyx_n_s_strip, __pyx_k_strip, sizeof(__pyx_k_strip), 0, 0, 1, 1},
  {&__pyx_n_s_structure, __pyx_k_structure, sizeof(__pyx_k_structure), 0, 0, 1, 1},
  {&__pyx_n_s_subint, __pyx_k_subint, sizeof(__pyx_k_subint), 0, 0, 1, 1},
  {&__pyx_n_s_subminor, __pyx_k_subminor, sizeof(__pyx_k_subminor), 0, 0, 1, 1},
  {&__pyx_n_s_svd_type, __pyx_k_svd_type, sizeof(__pyx_k_svd_type), 0, 0, 1, 1},
  {&__pyx_n_s_t, __pyx_k_t, sizeof(__pyx_k_t), 0, 0, 1, 1},
  {&__pyx_n_s_target, __pyx_k_target, sizeof(__pyx_k_target), 0, 0, 1, 1},
  {&__pyx_n_s_tau, __pyx_k_tau, sizeof(__pyx_k_tau), 0, 0, 1, 1},
  {&__pyx_n_s_tol, __pyx_k_tol, sizeof(__pyx_k_tol), 0, 0, 1, 1},
  {&__pyx_n_s_trackall, __pyx_k_trackall, sizeof(__pyx_k_trackall), 0, 0, 1, 1},
  {&__pyx_n_s_trim, __pyx_k_trim, sizeof(__pyx_k_trim), 0, 0, 1, 1},
  {&__pyx_n_s_trueres, __pyx_k_trueres, sizeof(__pyx_k_trueres), 0, 0, 1, 1},
  {&__pyx_n_s_twosided, __pyx_k_twosided, sizeof(__pyx_k_twosided), 0, 0, 1, 1},
  {&__pyx_n_s_usest, __pyx_k_usest, sizeof(__pyx_k_usest), 0, 0, 1, 1},
  {&__pyx_n_s_v, __pyx_k_v, sizeof(__pyx_k_v), 0, 0, 1, 1},
  {&__pyx_n_s_vertical, __pyx_k_vertical, sizeof(__pyx_k_vertical), 0, 0, 1, 1},
  {&__pyx_n_s_viewer, __pyx_k_viewer, sizeof(__pyx_k_viewer), 0, 0, 1, 1},
  {&__pyx_n_s_vscale, __pyx_k_vscale, sizeof(__pyx_k_vscale), 0, 0, 1, 1},
  {&__pyx_n_s_w, __pyx_k_w, sizeof(__pyx_k_w), 0, 0, 1, 1},
  {&__pyx_n_s_which, __pyx_k_which, sizeof(__pyx_k_which), 0, 0, 1, 1},
  {&__pyx_n_s_width, __pyx_k_width, sizeof(__pyx_k_width), 0, 0, 1, 1},
  {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1},
  {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1},
  {0, 0, 0, 0, 0, 0, 0}
};
static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
  __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_n_s_object); if (!__pyx_builtin_object) __PYX_ERR(0, 3, __pyx_L1_error)
  __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 21, __pyx_L1_error)
  __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(2, 128, __pyx_L1_error)
  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(2, 128, __pyx_L1_error)
  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(3, 387, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}

static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);

  /* "SLEPc/slepcbv.pxi":132
 *     if on is not None: n = asInt(on)
 *     if oN is not None: N = asInt(oN)
 *     if n==PETSC_DECIDE and N==PETSC_DECIDE: raise ValueError(             # <<<<<<<<<<<<<<
 *         "local and global sizes cannot be both 'DECIDE'")
 *     # return result to the caller
 */
  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_local_and_global_sizes_cannot_be); if (unlikely(!__pyx_tuple_)) __PYX_ERR(2, 132, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple_);
  __Pyx_GIVEREF(__pyx_tuple_);

  /* "SLEPc/Sys.pyx":19
 *                 vstr = bytes2str(cversion)
 *                 if release != 0:
 *                     date = vstr.split(",", 1)[-1].strip()             # <<<<<<<<<<<<<<
 *                 else:
 *                     date = vstr.split("GIT Date:")[-1].strip()
 */
  __pyx_tuple__3 = PyTuple_Pack(2, __pyx_kp_s__2, __pyx_int_1); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(12, 19, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__3);
  __Pyx_GIVEREF(__pyx_tuple__3);

  /* "SLEPc/Sys.pyx":31
 *     @classmethod
 *     def getVersionInfo(cls):
 *         version, dev, date, author = cls.getVersion(True, True, True)             # <<<<<<<<<<<<<<
 *         return dict(major      = version[0],
 *                     minor      = version[1],
 */
  __pyx_tuple__5 = PyTuple_Pack(3, Py_True, Py_True, Py_True); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(12, 31, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__5);
  __Pyx_GIVEREF(__pyx_tuple__5);

  /* "SLEPc/ST.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class STType(object):             # <<<<<<<<<<<<<<
 *     """
 *     ST types
 */
  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__6);
  __Pyx_GIVEREF(__pyx_tuple__6);

  /* "SLEPc/ST.pyx":21
 *     FILTER  = S_(STFILTER)
 * 
 * class STMatMode(object):             # <<<<<<<<<<<<<<
 *     """
 *     ST matrix mode
 */
  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 21, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__7);
  __Pyx_GIVEREF(__pyx_tuple__7);

  /* "SLEPc/BV.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class BVType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV type
 */
  __pyx_tuple__8 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(13, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__8);
  __Pyx_GIVEREF(__pyx_tuple__8);

  /* "SLEPc/BV.pyx":13
 *     TENSOR     = S_(BVTENSOR)
 * 
 * class BVOrthogType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV orthogonalization types
 */
  __pyx_tuple__9 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(13, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__9);
  __Pyx_GIVEREF(__pyx_tuple__9);

  /* "SLEPc/BV.pyx":23
 *     MGS = BV_ORTHOG_MGS
 * 
 * class BVOrthogRefineType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV orthogonalization refinement types
 */
  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(13, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__10);
  __Pyx_GIVEREF(__pyx_tuple__10);

  /* "SLEPc/BV.pyx":35
 *     ALWAYS   = BV_ORTHOG_REFINE_ALWAYS
 * 
 * class BVOrthogBlockType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV block-orthogonalization types
 */
  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(13, 35, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__11);
  __Pyx_GIVEREF(__pyx_tuple__11);

  /* "SLEPc/BV.pyx":51
 *     SVQB     = BV_ORTHOG_BLOCK_SVQB
 * 
 * class BVMatMultType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV mat-mult types
 */
  __pyx_tuple__12 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(13, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__12);
  __Pyx_GIVEREF(__pyx_tuple__12);

  /* "SLEPc/BV.pyx":61
 *     MAT      = BV_MATMULT_MAT
 * 
 * class BVSVDMethod(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV methods for computing the SVD
 */
  __pyx_tuple__13 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(13, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__13);
  __Pyx_GIVEREF(__pyx_tuple__13);

  /* "SLEPc/DS.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class DSType(object):             # <<<<<<<<<<<<<<
 *     """
 *     DS type
 */
  __pyx_tuple__14 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(14, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__14);
  __Pyx_GIVEREF(__pyx_tuple__14);

  /* "SLEPc/DS.pyx":18
 *     NEP     = S_(DSNEP)
 * 
 * class DSStateType(object):             # <<<<<<<<<<<<<<
 *     """
 *     DS state types
 */
  __pyx_tuple__15 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(14, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__15);
  __Pyx_GIVEREF(__pyx_tuple__15);

  /* "SLEPc/DS.pyx":32
 *     TRUNCATED    = DS_STATE_TRUNCATED
 * 
 * class DSMatType(object):             # <<<<<<<<<<<<<<
 *     """
 *     To refer to one of the matrices stored internally in DS
 */
  __pyx_tuple__16 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(14, 32, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__16);
  __Pyx_GIVEREF(__pyx_tuple__16);

  /* "SLEPc/DS.pyx":62
 *     W  = DS_MAT_W
 * 
 * class DSParallelType(object):             # <<<<<<<<<<<<<<
 *     """
 *     DS parallel types
 */
  __pyx_tuple__17 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(14, 62, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__17);
  __Pyx_GIVEREF(__pyx_tuple__17);

  /* "SLEPc/FN.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class FNType(object):             # <<<<<<<<<<<<<<
 *     """
 *     FN type
 */
  __pyx_tuple__18 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(15, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__18);
  __Pyx_GIVEREF(__pyx_tuple__18);

  /* "SLEPc/FN.pyx":15
 *     INVSQRT  = S_(FNINVSQRT)
 * 
 * class FNCombineType(object):             # <<<<<<<<<<<<<<
 *     """
 *     FN type of combination of child functions
 */
  __pyx_tuple__19 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(15, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__19);
  __Pyx_GIVEREF(__pyx_tuple__19);

  /* "SLEPc/FN.pyx":29
 *     COMPOSE  = FN_COMBINE_COMPOSE
 * 
 * class FNParallelType(object):             # <<<<<<<<<<<<<<
 *     """
 *     FN parallel types
 */
  __pyx_tuple__20 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(15, 29, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__20);
  __Pyx_GIVEREF(__pyx_tuple__20);

  /* "SLEPc/RG.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class RGType(object):             # <<<<<<<<<<<<<<
 *     """
 *     RG type
 */
  __pyx_tuple__21 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(16, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__21);
  __Pyx_GIVEREF(__pyx_tuple__21);

  /* "SLEPc/RG.pyx":12
 *     RING       = S_(RGRING)
 * 
 * class RGQuadRule(object):             # <<<<<<<<<<<<<<
 *     """
 *     RG quadrature rule for contour integral methods
 */
  __pyx_tuple__22 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(16, 12, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__22);
  __Pyx_GIVEREF(__pyx_tuple__22);

  /* "SLEPc/EPS.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class EPSType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS type
 */
  __pyx_tuple__23 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(17, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__23);
  __Pyx_GIVEREF(__pyx_tuple__23);

  /* "SLEPc/EPS.pyx":59
 *     EVSL         = S_(EPSEVSL)
 * 
 * class EPSProblemType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS problem type
 */
  __pyx_tuple__24 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(17, 59, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__24);
  __Pyx_GIVEREF(__pyx_tuple__24);

  /* "SLEPc/EPS.pyx":78
 *     GHIEP  = EPS_GHIEP
 * 
 * class EPSExtraction(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS extraction technique
 */
  __pyx_tuple__25 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(17, 78, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__25);
  __Pyx_GIVEREF(__pyx_tuple__25);

  /* "SLEPc/EPS.pyx":98
 *     REFINED_HARMONIC  = EPS_REFINED_HARMONIC
 * 
 * class EPSBalance(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS type of balancing used for non-Hermitian problems
 */
  __pyx_tuple__26 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(17, 98, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__26);
  __Pyx_GIVEREF(__pyx_tuple__26);

  /* "SLEPc/EPS.pyx":112
 *     USER    = EPS_BALANCE_USER
 * 
 * class EPSErrorType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS error type to assess accuracy of computed solutions
 */
  __pyx_tuple__27 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(17, 112, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__27);
  __Pyx_GIVEREF(__pyx_tuple__27);

  /* "SLEPc/EPS.pyx":124
 *     BACKWARD = EPS_ERROR_BACKWARD
 * 
 * class EPSWhich(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS desired part of spectrum
 */
  __pyx_tuple__28 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(17, 124, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__28);
  __Pyx_GIVEREF(__pyx_tuple__28);

  /* "SLEPc/EPS.pyx":152
 *     USER               = EPS_WHICH_USER
 * 
 * class EPSConv(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS convergence test
 */
  __pyx_tuple__29 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(17, 152, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__29);
  __Pyx_GIVEREF(__pyx_tuple__29);

  /* "SLEPc/EPS.pyx":166
 *     USER = EPS_CONV_USER
 * 
 * class EPSStop(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS stopping test
 */
  __pyx_tuple__30 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(17, 166, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__30);
  __Pyx_GIVEREF(__pyx_tuple__30);

  /* "SLEPc/EPS.pyx":176
 *     USER  = EPS_STOP_USER
 * 
 * class EPSConvergedReason(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS convergence reasons
 */
  __pyx_tuple__31 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(17, 176, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__31);
  __Pyx_GIVEREF(__pyx_tuple__31);

  /* "SLEPc/EPS.pyx":195
 *     ITERATING              = EPS_CONVERGED_ITERATING
 * 
 * class EPSPowerShiftType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS Power shift type.
 */
  __pyx_tuple__32 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(17, 195, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__32);
  __Pyx_GIVEREF(__pyx_tuple__32);

  /* "SLEPc/EPS.pyx":207
 *     WILKINSON = EPS_POWER_SHIFT_WILKINSON
 * 
 * class EPSLanczosReorthogType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS Lanczos reorthogonalization type
 */
  __pyx_tuple__33 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(17, 207, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__33);
  __Pyx_GIVEREF(__pyx_tuple__33);

  /* "SLEPc/EPS.pyx":225
 *     DELAYED   = EPS_LANCZOS_REORTHOG_DELAYED
 * 
 * class EPSCISSQuadRule(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS CISS quadrature rule
 */
  __pyx_tuple__34 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(17, 225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__34);
  __Pyx_GIVEREF(__pyx_tuple__34);

  /* "SLEPc/EPS.pyx":235
 *     CHEBYSHEV   = EPS_CISS_QUADRULE_CHEBYSHEV
 * 
 * class EPSCISSExtraction(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS CISS extraction technique
 */
  __pyx_tuple__35 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(17, 235, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__35);
  __Pyx_GIVEREF(__pyx_tuple__35);

  /* "SLEPc/SVD.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class SVDType(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD types
 */
  __pyx_tuple__36 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(18, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__36);
  __Pyx_GIVEREF(__pyx_tuple__36);

  /* "SLEPc/SVD.pyx":31
 *     PRIMME     = S_(SVDPRIMME)
 * 
 * class SVDProblemType(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD problem type
 */
  __pyx_tuple__37 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(18, 31, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__37);
  __Pyx_GIVEREF(__pyx_tuple__37);

  /* "SLEPc/SVD.pyx":43
 *     HYPERBOLIC  = SVD_HYPERBOLIC
 * 
 * class SVDErrorType(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD error type to assess accuracy of computed solutions
 */
  __pyx_tuple__38 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(18, 43, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__38);
  __Pyx_GIVEREF(__pyx_tuple__38);

  /* "SLEPc/SVD.pyx":55
 *     NORM     = SVD_ERROR_NORM
 * 
 * class SVDWhich(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD desired part of spectrum
 */
  __pyx_tuple__39 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(18, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__39);
  __Pyx_GIVEREF(__pyx_tuple__39);

  /* "SLEPc/SVD.pyx":65
 *     SMALLEST = SVD_SMALLEST
 * 
 * class SVDConv(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD convergence test
 */
  __pyx_tuple__40 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(18, 65, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__40);
  __Pyx_GIVEREF(__pyx_tuple__40);

  /* "SLEPc/SVD.pyx":81
 *     USER  = SVD_CONV_USER
 * 
 * class SVDStop(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD stopping test
 */
  __pyx_tuple__41 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(18, 81, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__41);
  __Pyx_GIVEREF(__pyx_tuple__41);

  /* "SLEPc/SVD.pyx":91
 *     USER  = SVD_STOP_USER
 * 
 * class SVDConvergedReason(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD convergence reasons
 */
  __pyx_tuple__42 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(18, 91, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__42);
  __Pyx_GIVEREF(__pyx_tuple__42);

  /* "SLEPc/SVD.pyx":110
 *     ITERATING           = SVD_CONVERGED_ITERATING
 * 
 * class SVDTRLanczosGBidiag(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD TRLanczos bidiagonalization choices for the GSVD case
 */
  __pyx_tuple__43 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(18, 110, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__43);
  __Pyx_GIVEREF(__pyx_tuple__43);

  /* "SLEPc/PEP.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class PEPType(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP type
 */
  __pyx_tuple__44 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(19, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__44);
  __Pyx_GIVEREF(__pyx_tuple__44);

  /* "SLEPc/PEP.pyx":23
 *     CISS     = S_(PEPCISS)
 * 
 * class PEPProblemType(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP problem type
 */
  __pyx_tuple__45 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(19, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__45);
  __Pyx_GIVEREF(__pyx_tuple__45);

  /* "SLEPc/PEP.pyx":37
 *     GYROSCOPIC = PEP_GYROSCOPIC
 * 
 * class PEPWhich(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP desired part of spectrum
 */
  __pyx_tuple__46 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(19, 37, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__46);
  __Pyx_GIVEREF(__pyx_tuple__46);

  /* "SLEPc/PEP.pyx":65
 *     USER               = PEP_WHICH_USER
 * 
 * class PEPBasis(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP basis type for the representation of the polynomial
 */
  __pyx_tuple__47 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(19, 65, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__47);
  __Pyx_GIVEREF(__pyx_tuple__47);

  /* "SLEPc/PEP.pyx":83
 *     HERMITE    = PEP_BASIS_HERMITE
 * 
 * class PEPScale(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP scaling strategy
 */
  __pyx_tuple__48 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(19, 83, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__48);
  __Pyx_GIVEREF(__pyx_tuple__48);

  /* "SLEPc/PEP.pyx":97
 *     BOTH     = PEP_SCALE_BOTH
 * 
 * class PEPRefine(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP refinement strategy
 */
  __pyx_tuple__49 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(19, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__49);
  __Pyx_GIVEREF(__pyx_tuple__49);

  /* "SLEPc/PEP.pyx":109
 *     MULTIPLE = PEP_REFINE_MULTIPLE
 * 
 * class PEPRefineScheme(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP scheme for solving linear systems during iterative refinement
 */
  __pyx_tuple__50 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(19, 109, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__50);
  __Pyx_GIVEREF(__pyx_tuple__50);

  /* "SLEPc/PEP.pyx":121
 *     EXPLICIT = PEP_REFINE_SCHEME_EXPLICIT
 * 
 * class PEPExtract(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP extraction strategy used to obtain eigenvectors of the PEP from the
 */
  __pyx_tuple__51 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(19, 121, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__51);
  __Pyx_GIVEREF(__pyx_tuple__51);

  /* "SLEPc/PEP.pyx":136
 *     STRUCTURED = PEP_EXTRACT_STRUCTURED
 * 
 * class PEPErrorType(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP error type to assess accuracy of computed solutions
 */
  __pyx_tuple__52 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(19, 136, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__52);
  __Pyx_GIVEREF(__pyx_tuple__52);

  /* "SLEPc/PEP.pyx":148
 *     BACKWARD = PEP_ERROR_BACKWARD
 * 
 * class PEPConv(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP convergence test
 */
  __pyx_tuple__53 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(19, 148, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__53);
  __Pyx_GIVEREF(__pyx_tuple__53);

  /* "SLEPc/PEP.pyx":162
 *     USER = PEP_CONV_USER
 * 
 * class PEPStop(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP stopping test
 */
  __pyx_tuple__54 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(19, 162, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__54);
  __Pyx_GIVEREF(__pyx_tuple__54);

  /* "SLEPc/PEP.pyx":172
 *     USER  = PEP_STOP_USER
 * 
 * class PEPConvergedReason(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP convergence reasons
 */
  __pyx_tuple__55 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(19, 172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__55);
  __Pyx_GIVEREF(__pyx_tuple__55);

  /* "SLEPc/PEP.pyx":191
 *     ITERATING              = PEP_CONVERGED_ITERATING
 * 
 * class PEPJDProjection(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP type of projection to be used in the Jacobi-Davidson solver
 */
  __pyx_tuple__56 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(19, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__56);
  __Pyx_GIVEREF(__pyx_tuple__56);

  /* "SLEPc/PEP.pyx":201
 *     ORTHOGONAL = PEP_JD_PROJECTION_ORTHOGONAL
 * 
 * class PEPCISSExtraction(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP CISS extraction technique
 */
  __pyx_tuple__57 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(19, 201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__57);
  __Pyx_GIVEREF(__pyx_tuple__57);

  /* "SLEPc/NEP.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class NEPType(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP type
 */
  __pyx_tuple__58 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(20, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__58);
  __Pyx_GIVEREF(__pyx_tuple__58);

  /* "SLEPc/NEP.pyx":23
 *     NLEIGS   = S_(NEPNLEIGS)
 * 
 * class NEPProblemType(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP problem type
 */
  __pyx_tuple__59 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(20, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__59);
  __Pyx_GIVEREF(__pyx_tuple__59);

  /* "SLEPc/NEP.pyx":33
 *     RATIONAL = NEP_RATIONAL
 * 
 * class NEPErrorType(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP error type to assess accuracy of computed solutions
 */
  __pyx_tuple__60 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(20, 33, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__60);
  __Pyx_GIVEREF(__pyx_tuple__60);

  /* "SLEPc/NEP.pyx":45
 *     BACKWARD = NEP_ERROR_BACKWARD
 * 
 * class NEPWhich(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP desired part of spectrum
 */
  __pyx_tuple__61 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(20, 45, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__61);
  __Pyx_GIVEREF(__pyx_tuple__61);

  /* "SLEPc/NEP.pyx":73
 *     USER               = NEP_WHICH_USER
 * 
 * class NEPConvergedReason(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP convergence reasons
 */
  __pyx_tuple__62 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(20, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__62);
  __Pyx_GIVEREF(__pyx_tuple__62);

  /* "SLEPc/NEP.pyx":94
 *     ITERATING                   = NEP_CONVERGED_ITERATING
 * 
 * class NEPRefine(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP refinement strategy
 */
  __pyx_tuple__63 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(20, 94, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__63);
  __Pyx_GIVEREF(__pyx_tuple__63);

  /* "SLEPc/NEP.pyx":106
 *     MULTIPLE = NEP_REFINE_MULTIPLE
 * 
 * class NEPRefineScheme(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP scheme for solving linear systems during iterative refinement
 */
  __pyx_tuple__64 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(20, 106, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__64);
  __Pyx_GIVEREF(__pyx_tuple__64);

  /* "SLEPc/NEP.pyx":118
 *     EXPLICIT = NEP_REFINE_SCHEME_EXPLICIT
 * 
 * class NEPConv(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP convergence test
 */
  __pyx_tuple__65 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(20, 118, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__65);
  __Pyx_GIVEREF(__pyx_tuple__65);

  /* "SLEPc/NEP.pyx":132
 *     USER = NEP_CONV_USER
 * 
 * class NEPStop(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP stopping test
 */
  __pyx_tuple__66 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(20, 132, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__66);
  __Pyx_GIVEREF(__pyx_tuple__66);

  /* "SLEPc/NEP.pyx":142
 *     USER  = NEP_STOP_USER
 * 
 * class NEPCISSExtraction(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP CISS extraction technique
 */
  __pyx_tuple__67 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(20, 142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__67);
  __Pyx_GIVEREF(__pyx_tuple__67);

  /* "SLEPc/MFN.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class MFNType(object):             # <<<<<<<<<<<<<<
 *     """
 *     MFN type
 */
  __pyx_tuple__68 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(21, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__68);
  __Pyx_GIVEREF(__pyx_tuple__68);

  /* "SLEPc/MFN.pyx":15
 *     EXPOKIT  = S_(MFNEXPOKIT)
 * 
 * class MFNConvergedReason(object):             # <<<<<<<<<<<<<<
 *     CONVERGED_TOL       = MFN_CONVERGED_TOL
 *     CONVERGED_ITS       = MFN_CONVERGED_ITS
 */
  __pyx_tuple__69 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(21, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__69);
  __Pyx_GIVEREF(__pyx_tuple__69);

  /* "SLEPc/SLEPc.pyx":256
 * # -----------------------------------------------------------------------------
 * 
 * def _initialize(args=None):             # <<<<<<<<<<<<<<
 *     cdef int ready = initialize(args)
 *     if ready: register(NULL)
 */
  __pyx_tuple__70 = PyTuple_Pack(2, __pyx_n_s_args, __pyx_n_s_ready); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(4, 256, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__70);
  __Pyx_GIVEREF(__pyx_tuple__70);
  __pyx_codeobj__71 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__70, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_SLEPc_SLEPc_pyx, __pyx_n_s_initialize, 256, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__71)) __PYX_ERR(4, 256, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":260
 *     if ready: register(NULL)
 * 
 * def _finalize():             # <<<<<<<<<<<<<<
 *     finalize()
 * 
 */
  __pyx_codeobj__72 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_SLEPc_SLEPc_pyx, __pyx_n_s_finalize, 260, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__72)) __PYX_ERR(4, 260, __pyx_L1_error)
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_RefNannyFinishContext();
  return -1;
}

static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(23, 1, __pyx_L1_error);
  __pyx_float_0_0 = PyFloat_FromDouble(0.0); if (unlikely(!__pyx_float_0_0)) __PYX_ERR(23, 1, __pyx_L1_error)
  __pyx_float_1_0 = PyFloat_FromDouble(1.0); if (unlikely(!__pyx_float_1_0)) __PYX_ERR(23, 1, __pyx_L1_error)
  __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(23, 1, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}

static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/

static int __Pyx_modinit_global_init_code(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
  /*--- Global init code ---*/
  __pyx_v_8slepc4py_5SLEPc_PetscError = Py_None; Py_INCREF(Py_None);
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_variable_export_code(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
  /*--- Variable export code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_function_export_code(void) {
  __Pyx_RefNannyDeclarations
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
  /*--- Function export code ---*/
  if (__Pyx_ExportFunction("PySlepcST_New", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcST_New, "PyObject *(ST)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcST_Get", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcST_Get, "ST (PyObject *)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcBV_New", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcBV_New, "PyObject *(BV)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcBV_Get", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcBV_Get, "BV (PyObject *)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcDS_New", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcDS_New, "PyObject *(DS)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcDS_Get", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcDS_Get, "DS (PyObject *)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcFN_New", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcFN_New, "PyObject *(FN)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcFN_Get", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcFN_Get, "FN (PyObject *)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcRG_New", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcRG_New, "PyObject *(RG)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcRG_Get", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcRG_Get, "RG (PyObject *)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcEPS_New", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcEPS_New, "PyObject *(EPS)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcEPS_Get", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcEPS_Get, "EPS (PyObject *)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcSVD_New", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcSVD_New, "PyObject *(SVD)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcSVD_Get", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcSVD_Get, "SVD (PyObject *)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcPEP_New", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcPEP_New, "PyObject *(PEP)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcPEP_Get", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcPEP_Get, "PEP (PyObject *)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcNEP_New", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcNEP_New, "PyObject *(NEP)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcNEP_Get", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcNEP_Get, "NEP (PyObject *)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcMFN_New", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcMFN_New, "PyObject *(MFN)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ExportFunction("PySlepcMFN_Get", (void (*)(void))__pyx_f_8slepc4py_5SLEPc_PySlepcMFN_Get, "MFN (PyObject *)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_RefNannyFinishContext();
  return -1;
}

static int __Pyx_modinit_type_init_code(void) {
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
  /*--- Type init code ---*/
  __pyx_t_1 = PyImport_ImportModule("petsc4py.PETSc"); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_ptype_8petsc4py_5PETSc_Object = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "Object", sizeof(struct PyPetscObjectObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_Object) __PYX_ERR(23, 1, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_Object = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Object*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_Object->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_Object)) __PYX_ERR(23, 1, __pyx_L1_error)
  __pyx_vtabptr_8slepc4py_5SLEPc_ST = &__pyx_vtable_8slepc4py_5SLEPc_ST;
  __pyx_vtable_8slepc4py_5SLEPc_ST.__pyx_base = *__pyx_vtabptr_8petsc4py_5PETSc_Object;
  PySlepcST_Type.tp_base = __pyx_ptype_8petsc4py_5PETSc_Object;
  if (PyType_Ready(&PySlepcST_Type) < 0) __PYX_ERR(0, 36, __pyx_L1_error)
  #if PY_VERSION_HEX < 0x030800B1
  PySlepcST_Type.tp_print = 0;
  #endif
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!PySlepcST_Type.tp_dictoffset && PySlepcST_Type.tp_getattro == PyObject_GenericGetAttr)) {
    PySlepcST_Type.tp_getattro = __Pyx_PyObject_GenericGetAttr;
  }
  if (__Pyx_SetVtable(PySlepcST_Type.tp_dict, __pyx_vtabptr_8slepc4py_5SLEPc_ST) < 0) __PYX_ERR(0, 36, __pyx_L1_error)
  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ST, (PyObject *)&PySlepcST_Type) < 0) __PYX_ERR(0, 36, __pyx_L1_error)
  if (PySlepcST_Type.tp_weaklistoffset == 0) PySlepcST_Type.tp_weaklistoffset = offsetof(struct PySlepcSTObject, __pyx_base.__weakref__);
  __pyx_ptype_8slepc4py_5SLEPc_ST = &PySlepcST_Type;
  __pyx_vtabptr_8slepc4py_5SLEPc_BV = &__pyx_vtable_8slepc4py_5SLEPc_BV;
  __pyx_vtable_8slepc4py_5SLEPc_BV.__pyx_base = *__pyx_vtabptr_8petsc4py_5PETSc_Object;
  PySlepcBV_Type.tp_base = __pyx_ptype_8petsc4py_5PETSc_Object;
  if (PyType_Ready(&PySlepcBV_Type) < 0) __PYX_ERR(13, 75, __pyx_L1_error)
  #if PY_VERSION_HEX < 0x030800B1
  PySlepcBV_Type.tp_print = 0;
  #endif
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!PySlepcBV_Type.tp_dictoffset && PySlepcBV_Type.tp_getattro == PyObject_GenericGetAttr)) {
    PySlepcBV_Type.tp_getattro = __Pyx_PyObject_GenericGetAttr;
  }
  if (__Pyx_SetVtable(PySlepcBV_Type.tp_dict, __pyx_vtabptr_8slepc4py_5SLEPc_BV) < 0) __PYX_ERR(13, 75, __pyx_L1_error)
  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_BV, (PyObject *)&PySlepcBV_Type) < 0) __PYX_ERR(13, 75, __pyx_L1_error)
  if (PySlepcBV_Type.tp_weaklistoffset == 0) PySlepcBV_Type.tp_weaklistoffset = offsetof(struct PySlepcBVObject, __pyx_base.__weakref__);
  __pyx_ptype_8slepc4py_5SLEPc_BV = &PySlepcBV_Type;
  __pyx_vtabptr_8slepc4py_5SLEPc_DS = &__pyx_vtable_8slepc4py_5SLEPc_DS;
  __pyx_vtable_8slepc4py_5SLEPc_DS.__pyx_base = *__pyx_vtabptr_8petsc4py_5PETSc_Object;
  PySlepcDS_Type.tp_base = __pyx_ptype_8petsc4py_5PETSc_Object;
  if (PyType_Ready(&PySlepcDS_Type) < 0) __PYX_ERR(14, 76, __pyx_L1_error)
  #if PY_VERSION_HEX < 0x030800B1
  PySlepcDS_Type.tp_print = 0;
  #endif
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!PySlepcDS_Type.tp_dictoffset && PySlepcDS_Type.tp_getattro == PyObject_GenericGetAttr)) {
    PySlepcDS_Type.tp_getattro = __Pyx_PyObject_GenericGetAttr;
  }
  if (__Pyx_SetVtable(PySlepcDS_Type.tp_dict, __pyx_vtabptr_8slepc4py_5SLEPc_DS) < 0) __PYX_ERR(14, 76, __pyx_L1_error)
  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_DS, (PyObject *)&PySlepcDS_Type) < 0) __PYX_ERR(14, 76, __pyx_L1_error)
  if (PySlepcDS_Type.tp_weaklistoffset == 0) PySlepcDS_Type.tp_weaklistoffset = offsetof(struct PySlepcDSObject, __pyx_base.__weakref__);
  __pyx_ptype_8slepc4py_5SLEPc_DS = &PySlepcDS_Type;
  __pyx_vtabptr_8slepc4py_5SLEPc_FN = &__pyx_vtable_8slepc4py_5SLEPc_FN;
  __pyx_vtable_8slepc4py_5SLEPc_FN.__pyx_base = *__pyx_vtabptr_8petsc4py_5PETSc_Object;
  PySlepcFN_Type.tp_base = __pyx_ptype_8petsc4py_5PETSc_Object;
  if (PyType_Ready(&PySlepcFN_Type) < 0) __PYX_ERR(15, 41, __pyx_L1_error)
  #if PY_VERSION_HEX < 0x030800B1
  PySlepcFN_Type.tp_print = 0;
  #endif
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!PySlepcFN_Type.tp_dictoffset && PySlepcFN_Type.tp_getattro == PyObject_GenericGetAttr)) {
    PySlepcFN_Type.tp_getattro = __Pyx_PyObject_GenericGetAttr;
  }
  if (__Pyx_SetVtable(PySlepcFN_Type.tp_dict, __pyx_vtabptr_8slepc4py_5SLEPc_FN) < 0) __PYX_ERR(15, 41, __pyx_L1_error)
  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FN, (PyObject *)&PySlepcFN_Type) < 0) __PYX_ERR(15, 41, __pyx_L1_error)
  if (PySlepcFN_Type.tp_weaklistoffset == 0) PySlepcFN_Type.tp_weaklistoffset = offsetof(struct PySlepcFNObject, __pyx_base.__weakref__);
  __pyx_ptype_8slepc4py_5SLEPc_FN = &PySlepcFN_Type;
  __pyx_vtabptr_8slepc4py_5SLEPc_RG = &__pyx_vtable_8slepc4py_5SLEPc_RG;
  __pyx_vtable_8slepc4py_5SLEPc_RG.__pyx_base = *__pyx_vtabptr_8petsc4py_5PETSc_Object;
  PySlepcRG_Type.tp_base = __pyx_ptype_8petsc4py_5PETSc_Object;
  if (PyType_Ready(&PySlepcRG_Type) < 0) __PYX_ERR(16, 24, __pyx_L1_error)
  #if PY_VERSION_HEX < 0x030800B1
  PySlepcRG_Type.tp_print = 0;
  #endif
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!PySlepcRG_Type.tp_dictoffset && PySlepcRG_Type.tp_getattro == PyObject_GenericGetAttr)) {
    PySlepcRG_Type.tp_getattro = __Pyx_PyObject_GenericGetAttr;
  }
  if (__Pyx_SetVtable(PySlepcRG_Type.tp_dict, __pyx_vtabptr_8slepc4py_5SLEPc_RG) < 0) __PYX_ERR(16, 24, __pyx_L1_error)
  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_RG, (PyObject *)&PySlepcRG_Type) < 0) __PYX_ERR(16, 24, __pyx_L1_error)
  if (PySlepcRG_Type.tp_weaklistoffset == 0) PySlepcRG_Type.tp_weaklistoffset = offsetof(struct PySlepcRGObject, __pyx_base.__weakref__);
  __pyx_ptype_8slepc4py_5SLEPc_RG = &PySlepcRG_Type;
  __pyx_vtabptr_8slepc4py_5SLEPc_EPS = &__pyx_vtable_8slepc4py_5SLEPc_EPS;
  __pyx_vtable_8slepc4py_5SLEPc_EPS.__pyx_base = *__pyx_vtabptr_8petsc4py_5PETSc_Object;
  PySlepcEPS_Type.tp_base = __pyx_ptype_8petsc4py_5PETSc_Object;
  if (PyType_Ready(&PySlepcEPS_Type) < 0) __PYX_ERR(17, 247, __pyx_L1_error)
  #if PY_VERSION_HEX < 0x030800B1
  PySlepcEPS_Type.tp_print = 0;
  #endif
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!PySlepcEPS_Type.tp_dictoffset && PySlepcEPS_Type.tp_getattro == PyObject_GenericGetAttr)) {
    PySlepcEPS_Type.tp_getattro = __Pyx_PyObject_GenericGetAttr;
  }
  if (__Pyx_SetVtable(PySlepcEPS_Type.tp_dict, __pyx_vtabptr_8slepc4py_5SLEPc_EPS) < 0) __PYX_ERR(17, 247, __pyx_L1_error)
  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_EPS, (PyObject *)&PySlepcEPS_Type) < 0) __PYX_ERR(17, 247, __pyx_L1_error)
  if (PySlepcEPS_Type.tp_weaklistoffset == 0) PySlepcEPS_Type.tp_weaklistoffset = offsetof(struct PySlepcEPSObject, __pyx_base.__weakref__);
  __pyx_ptype_8slepc4py_5SLEPc_EPS = &PySlepcEPS_Type;
  __pyx_vtabptr_8slepc4py_5SLEPc_SVD = &__pyx_vtable_8slepc4py_5SLEPc_SVD;
  __pyx_vtable_8slepc4py_5SLEPc_SVD.__pyx_base = *__pyx_vtabptr_8petsc4py_5PETSc_Object;
  PySlepcSVD_Type.tp_base = __pyx_ptype_8petsc4py_5PETSc_Object;
  if (PyType_Ready(&PySlepcSVD_Type) < 0) __PYX_ERR(18, 124, __pyx_L1_error)
  #if PY_VERSION_HEX < 0x030800B1
  PySlepcSVD_Type.tp_print = 0;
  #endif
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!PySlepcSVD_Type.tp_dictoffset && PySlepcSVD_Type.tp_getattro == PyObject_GenericGetAttr)) {
    PySlepcSVD_Type.tp_getattro = __Pyx_PyObject_GenericGetAttr;
  }
  if (__Pyx_SetVtable(PySlepcSVD_Type.tp_dict, __pyx_vtabptr_8slepc4py_5SLEPc_SVD) < 0) __PYX_ERR(18, 124, __pyx_L1_error)
  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SVD, (PyObject *)&PySlepcSVD_Type) < 0) __PYX_ERR(18, 124, __pyx_L1_error)
  if (PySlepcSVD_Type.tp_weaklistoffset == 0) PySlepcSVD_Type.tp_weaklistoffset = offsetof(struct PySlepcSVDObject, __pyx_base.__weakref__);
  __pyx_ptype_8slepc4py_5SLEPc_SVD = &PySlepcSVD_Type;
  __pyx_vtabptr_8slepc4py_5SLEPc_PEP = &__pyx_vtable_8slepc4py_5SLEPc_PEP;
  __pyx_vtable_8slepc4py_5SLEPc_PEP.__pyx_base = *__pyx_vtabptr_8petsc4py_5PETSc_Object;
  PySlepcPEP_Type.tp_base = __pyx_ptype_8petsc4py_5PETSc_Object;
  if (PyType_Ready(&PySlepcPEP_Type) < 0) __PYX_ERR(19, 215, __pyx_L1_error)
  #if PY_VERSION_HEX < 0x030800B1
  PySlepcPEP_Type.tp_print = 0;
  #endif
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!PySlepcPEP_Type.tp_dictoffset && PySlepcPEP_Type.tp_getattro == PyObject_GenericGetAttr)) {
    PySlepcPEP_Type.tp_getattro = __Pyx_PyObject_GenericGetAttr;
  }
  if (__Pyx_SetVtable(PySlepcPEP_Type.tp_dict, __pyx_vtabptr_8slepc4py_5SLEPc_PEP) < 0) __PYX_ERR(19, 215, __pyx_L1_error)
  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PEP, (PyObject *)&PySlepcPEP_Type) < 0) __PYX_ERR(19, 215, __pyx_L1_error)
  if (PySlepcPEP_Type.tp_weaklistoffset == 0) PySlepcPEP_Type.tp_weaklistoffset = offsetof(struct PySlepcPEPObject, __pyx_base.__weakref__);
  __pyx_ptype_8slepc4py_5SLEPc_PEP = &PySlepcPEP_Type;
  __pyx_vtabptr_8slepc4py_5SLEPc_NEP = &__pyx_vtable_8slepc4py_5SLEPc_NEP;
  __pyx_vtable_8slepc4py_5SLEPc_NEP.__pyx_base = *__pyx_vtabptr_8petsc4py_5PETSc_Object;
  PySlepcNEP_Type.tp_base = __pyx_ptype_8petsc4py_5PETSc_Object;
  if (PyType_Ready(&PySlepcNEP_Type) < 0) __PYX_ERR(20, 156, __pyx_L1_error)
  #if PY_VERSION_HEX < 0x030800B1
  PySlepcNEP_Type.tp_print = 0;
  #endif
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!PySlepcNEP_Type.tp_dictoffset && PySlepcNEP_Type.tp_getattro == PyObject_GenericGetAttr)) {
    PySlepcNEP_Type.tp_getattro = __Pyx_PyObject_GenericGetAttr;
  }
  if (__Pyx_SetVtable(PySlepcNEP_Type.tp_dict, __pyx_vtabptr_8slepc4py_5SLEPc_NEP) < 0) __PYX_ERR(20, 156, __pyx_L1_error)
  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_NEP, (PyObject *)&PySlepcNEP_Type) < 0) __PYX_ERR(20, 156, __pyx_L1_error)
  if (PySlepcNEP_Type.tp_weaklistoffset == 0) PySlepcNEP_Type.tp_weaklistoffset = offsetof(struct PySlepcNEPObject, __pyx_base.__weakref__);
  __pyx_ptype_8slepc4py_5SLEPc_NEP = &PySlepcNEP_Type;
  __pyx_vtabptr_8slepc4py_5SLEPc_MFN = &__pyx_vtable_8slepc4py_5SLEPc_MFN;
  __pyx_vtable_8slepc4py_5SLEPc_MFN.__pyx_base = *__pyx_vtabptr_8petsc4py_5PETSc_Object;
  PySlepcMFN_Type.tp_base = __pyx_ptype_8petsc4py_5PETSc_Object;
  if (PyType_Ready(&PySlepcMFN_Type) < 0) __PYX_ERR(21, 25, __pyx_L1_error)
  #if PY_VERSION_HEX < 0x030800B1
  PySlepcMFN_Type.tp_print = 0;
  #endif
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!PySlepcMFN_Type.tp_dictoffset && PySlepcMFN_Type.tp_getattro == PyObject_GenericGetAttr)) {
    PySlepcMFN_Type.tp_getattro = __Pyx_PyObject_GenericGetAttr;
  }
  if (__Pyx_SetVtable(PySlepcMFN_Type.tp_dict, __pyx_vtabptr_8slepc4py_5SLEPc_MFN) < 0) __PYX_ERR(21, 25, __pyx_L1_error)
  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MFN, (PyObject *)&PySlepcMFN_Type) < 0) __PYX_ERR(21, 25, __pyx_L1_error)
  if (PySlepcMFN_Type.tp_weaklistoffset == 0) PySlepcMFN_Type.tp_weaklistoffset = offsetof(struct PySlepcMFNObject, __pyx_base.__weakref__);
  __pyx_ptype_8slepc4py_5SLEPc_MFN = &PySlepcMFN_Type;
  if (PyType_Ready(&__pyx_type_8slepc4py_5SLEPc__p_mem) < 0) __PYX_ERR(1, 11, __pyx_L1_error)
  #if PY_VERSION_HEX < 0x030800B1
  __pyx_type_8slepc4py_5SLEPc__p_mem.tp_print = 0;
  #endif
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_8slepc4py_5SLEPc__p_mem.tp_dictoffset && __pyx_type_8slepc4py_5SLEPc__p_mem.tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_type_8slepc4py_5SLEPc__p_mem.tp_getattro = __Pyx_PyObject_GenericGetAttr;
  }
  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_p_mem, (PyObject *)&__pyx_type_8slepc4py_5SLEPc__p_mem) < 0) __PYX_ERR(1, 11, __pyx_L1_error)
  __pyx_ptype_8slepc4py_5SLEPc__p_mem = &__pyx_type_8slepc4py_5SLEPc__p_mem;
  __pyx_t_2 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_ptype_8slepc4py_5SLEPc_dtype = __Pyx_ImportType(__pyx_t_2, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8slepc4py_5SLEPc_dtype) __PYX_ERR(5, 9, __pyx_L1_error)
  __pyx_ptype_8slepc4py_5SLEPc_ndarray = __Pyx_ImportType(__pyx_t_2, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8slepc4py_5SLEPc_ndarray) __PYX_ERR(5, 12, __pyx_L1_error)
  if (PyType_Ready(&__pyx_type_8slepc4py_5SLEPc_Sys) < 0) __PYX_ERR(12, 3, __pyx_L1_error)
  #if PY_VERSION_HEX < 0x030800B1
  __pyx_type_8slepc4py_5SLEPc_Sys.tp_print = 0;
  #endif
  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_8slepc4py_5SLEPc_Sys.tp_dictoffset && __pyx_type_8slepc4py_5SLEPc_Sys.tp_getattro == PyObject_GenericGetAttr)) {
    __pyx_type_8slepc4py_5SLEPc_Sys.tp_getattro = __Pyx_PyObject_GenericGetAttr;
  }
  if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Sys, (PyObject *)&__pyx_type_8slepc4py_5SLEPc_Sys) < 0) __PYX_ERR(12, 3, __pyx_L1_error)
  __pyx_ptype_8slepc4py_5SLEPc_Sys = &__pyx_type_8slepc4py_5SLEPc_Sys;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_RefNannyFinishContext();
  return -1;
}

static int __Pyx_modinit_type_import_code(void) {
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
  /*--- Type import code ---*/
  __pyx_t_1 = PyImport_ImportModule("petsc4py.PETSc"); if (unlikely(!__pyx_t_1)) __PYX_ERR(24, 103, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_ptype_8petsc4py_5PETSc_Comm = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "Comm", sizeof(struct PyPetscCommObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_Comm) __PYX_ERR(24, 103, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_Viewer = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "Viewer", sizeof(struct PyPetscViewerObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_Viewer) __PYX_ERR(24, 123, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_Viewer = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Viewer*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_Viewer->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_Viewer)) __PYX_ERR(24, 123, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_Random = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "Random", sizeof(struct PyPetscRandomObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_Random) __PYX_ERR(24, 129, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_Random = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Random*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_Random->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_Random)) __PYX_ERR(24, 129, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_IS = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "IS", sizeof(struct PyPetscISObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_IS) __PYX_ERR(24, 135, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_IS = (struct __pyx_vtabstruct_8petsc4py_5PETSc_IS*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_IS->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_IS)) __PYX_ERR(24, 135, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_LGMap = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "LGMap", sizeof(struct PyPetscLGMapObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_LGMap) __PYX_ERR(24, 141, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_LGMap = (struct __pyx_vtabstruct_8petsc4py_5PETSc_LGMap*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_LGMap->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_LGMap)) __PYX_ERR(24, 141, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_SF = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "SF", sizeof(struct PyPetscSFObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_SF) __PYX_ERR(24, 147, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_SF = (struct __pyx_vtabstruct_8petsc4py_5PETSc_SF*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_SF->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_SF)) __PYX_ERR(24, 147, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_Vec = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "Vec", sizeof(struct PyPetscVecObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_Vec) __PYX_ERR(24, 153, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_Vec = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Vec*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_Vec->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_Vec)) __PYX_ERR(24, 153, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_Space = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "Space", sizeof(struct PyPetscSpaceObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_Space) __PYX_ERR(24, 159, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_Space = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Space*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_Space->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_Space)) __PYX_ERR(24, 159, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_DualSpace = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "DualSpace", sizeof(struct PyPetscDualSpaceObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_DualSpace) __PYX_ERR(24, 165, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_DualSpace = (struct __pyx_vtabstruct_8petsc4py_5PETSc_DualSpace*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_DualSpace->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_DualSpace)) __PYX_ERR(24, 165, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_FE = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "FE", sizeof(struct PyPetscFEObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_FE) __PYX_ERR(24, 171, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_FE = (struct __pyx_vtabstruct_8petsc4py_5PETSc_FE*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_FE->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_FE)) __PYX_ERR(24, 171, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_Quad = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "Quad", sizeof(struct PyPetscQuadObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_Quad) __PYX_ERR(24, 177, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_Quad = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Quad*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_Quad->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_Quad)) __PYX_ERR(24, 177, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_Scatter = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "Scatter", sizeof(struct PyPetscScatterObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_Scatter) __PYX_ERR(24, 183, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_Scatter = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Scatter*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_Scatter->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_Scatter)) __PYX_ERR(24, 183, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_Section = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "Section", sizeof(struct PyPetscSectionObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_Section) __PYX_ERR(24, 189, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_Section = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Section*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_Section->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_Section)) __PYX_ERR(24, 189, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_Mat = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "Mat", sizeof(struct PyPetscMatObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_Mat) __PYX_ERR(24, 195, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_Mat = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Mat*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_Mat->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_Mat)) __PYX_ERR(24, 195, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_MatPartitioning = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "MatPartitioning", sizeof(struct PyPetscMatPartitioningObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_MatPartitioning) __PYX_ERR(24, 201, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_MatPartitioning = (struct __pyx_vtabstruct_8petsc4py_5PETSc_MatPartitioning*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_MatPartitioning->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_MatPartitioning)) __PYX_ERR(24, 201, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_NullSpace = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "NullSpace", sizeof(struct PyPetscNullSpaceObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_NullSpace) __PYX_ERR(24, 207, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_NullSpace = (struct __pyx_vtabstruct_8petsc4py_5PETSc_NullSpace*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_NullSpace->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_NullSpace)) __PYX_ERR(24, 207, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_PC = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "PC", sizeof(struct PyPetscPCObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_PC) __PYX_ERR(24, 213, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_PC = (struct __pyx_vtabstruct_8petsc4py_5PETSc_PC*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_PC->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_PC)) __PYX_ERR(24, 213, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_KSP = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "KSP", sizeof(struct PyPetscKSPObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_KSP) __PYX_ERR(24, 219, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_KSP = (struct __pyx_vtabstruct_8petsc4py_5PETSc_KSP*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_KSP->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_KSP)) __PYX_ERR(24, 219, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_SNES = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "SNES", sizeof(struct PyPetscSNESObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_SNES) __PYX_ERR(24, 225, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_SNES = (struct __pyx_vtabstruct_8petsc4py_5PETSc_SNES*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_SNES->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_SNES)) __PYX_ERR(24, 225, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_TS = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "TS", sizeof(struct PyPetscTSObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_TS) __PYX_ERR(24, 231, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_TS = (struct __pyx_vtabstruct_8petsc4py_5PETSc_TS*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_TS->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_TS)) __PYX_ERR(24, 231, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_TAO = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "TAO", sizeof(struct PyPetscTAOObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_TAO) __PYX_ERR(24, 237, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_TAO = (struct __pyx_vtabstruct_8petsc4py_5PETSc_TAO*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_TAO->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_TAO)) __PYX_ERR(24, 237, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_AO = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "AO", sizeof(struct PyPetscAOObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_AO) __PYX_ERR(24, 243, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_AO = (struct __pyx_vtabstruct_8petsc4py_5PETSc_AO*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_AO->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_AO)) __PYX_ERR(24, 243, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_DM = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "DM", sizeof(struct PyPetscDMObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_DM) __PYX_ERR(24, 249, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_DM = (struct __pyx_vtabstruct_8petsc4py_5PETSc_DM*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_DM->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_DM)) __PYX_ERR(24, 249, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_DS = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "DS", sizeof(struct PyPetscDSObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_DS) __PYX_ERR(24, 255, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_DS = (struct __pyx_vtabstruct_8petsc4py_5PETSc_DS*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_DS->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_DS)) __PYX_ERR(24, 255, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_Partitioner = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "Partitioner", sizeof(struct PyPetscPartitionerObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_Partitioner) __PYX_ERR(24, 261, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_Partitioner = (struct __pyx_vtabstruct_8petsc4py_5PETSc_Partitioner*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_Partitioner->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_Partitioner)) __PYX_ERR(24, 261, __pyx_L1_error)
  __pyx_ptype_8petsc4py_5PETSc_DMLabel = __Pyx_ImportType(__pyx_t_1, "petsc4py.PETSc", "DMLabel", sizeof(struct PyPetscDMLabelObject), __Pyx_ImportType_CheckSize_Warn);
   if (!__pyx_ptype_8petsc4py_5PETSc_DMLabel) __PYX_ERR(24, 267, __pyx_L1_error)
  __pyx_vtabptr_8petsc4py_5PETSc_DMLabel = (struct __pyx_vtabstruct_8petsc4py_5PETSc_DMLabel*)__Pyx_GetVtable(__pyx_ptype_8petsc4py_5PETSc_DMLabel->tp_dict); if (unlikely(!__pyx_vtabptr_8petsc4py_5PETSc_DMLabel)) __PYX_ERR(24, 267, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_RefNannyFinishContext();
  return -1;
}

static int __Pyx_modinit_variable_import_code(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
  /*--- Variable import code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_function_import_code(void) {
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
  /*--- Function import code ---*/
  __pyx_t_1 = PyImport_ImportModule("petsc4py.PETSc"); if (!__pyx_t_1) __PYX_ERR(23, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (__Pyx_ImportFunction(__pyx_t_1, "GetComm", (void (**)(void))&__pyx_f_8petsc4py_5PETSc_GetComm, "MPI_Comm (PyObject *, MPI_Comm)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ImportFunction(__pyx_t_1, "GetCommDefault", (void (**)(void))&__pyx_f_8petsc4py_5PETSc_GetCommDefault, "MPI_Comm (void)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  if (__Pyx_ImportFunction(__pyx_t_1, "PyPetscType_Register", (void (**)(void))&__pyx_f_8petsc4py_5PETSc_PyPetscType_Register, "int (int, PyTypeObject *)") < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_RefNannyFinishContext();
  return -1;
}


#ifndef CYTHON_NO_PYINIT_EXPORT
#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
#elif PY_MAJOR_VERSION < 3
#ifdef __cplusplus
#define __Pyx_PyMODINIT_FUNC extern "C" void
#else
#define __Pyx_PyMODINIT_FUNC void
#endif
#else
#ifdef __cplusplus
#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
#else
#define __Pyx_PyMODINIT_FUNC PyObject *
#endif
#endif


#if PY_MAJOR_VERSION < 3
__Pyx_PyMODINIT_FUNC initSLEPc(void) CYTHON_SMALL_CODE; /*proto*/
__Pyx_PyMODINIT_FUNC initSLEPc(void)
#else
__Pyx_PyMODINIT_FUNC PyInit_SLEPc(void) CYTHON_SMALL_CODE; /*proto*/
__Pyx_PyMODINIT_FUNC PyInit_SLEPc(void)
#if CYTHON_PEP489_MULTI_PHASE_INIT
{
  return PyModuleDef_Init(&__pyx_moduledef);
}
static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
    #if PY_VERSION_HEX >= 0x030700A1
    static PY_INT64_T main_interpreter_id = -1;
    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
    if (main_interpreter_id == -1) {
        main_interpreter_id = current_id;
        return (unlikely(current_id == -1)) ? -1 : 0;
    } else if (unlikely(main_interpreter_id != current_id))
    #else
    static PyInterpreterState *main_interpreter = NULL;
    PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
    if (!main_interpreter) {
        main_interpreter = current_interpreter;
    } else if (unlikely(main_interpreter != current_interpreter))
    #endif
    {
        PyErr_SetString(
            PyExc_ImportError,
            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
        return -1;
    }
    return 0;
}
static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
    PyObject *value = PyObject_GetAttrString(spec, from_name);
    int result = 0;
    if (likely(value)) {
        if (allow_none || value != Py_None) {
            result = PyDict_SetItemString(moddict, to_name, value);
        }
        Py_DECREF(value);
    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
        PyErr_Clear();
    } else {
        result = -1;
    }
    return result;
}
static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
    PyObject *module = NULL, *moddict, *modname;
    if (__Pyx_check_single_interpreter())
        return NULL;
    if (__pyx_m)
        return __Pyx_NewRef(__pyx_m);
    modname = PyObject_GetAttrString(spec, "name");
    if (unlikely(!modname)) goto bad;
    module = PyModule_NewObject(modname);
    Py_DECREF(modname);
    if (unlikely(!module)) goto bad;
    moddict = PyModule_GetDict(module);
    if (unlikely(!moddict)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
    return module;
bad:
    Py_XDECREF(module);
    return NULL;
}


static CYTHON_SMALL_CODE int __pyx_pymod_exec_SLEPc(PyObject *__pyx_pyinit_module)
#endif
#endif
{
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  int __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  __Pyx_RefNannyDeclarations
  #if CYTHON_PEP489_MULTI_PHASE_INIT
  if (__pyx_m) {
    if (__pyx_m == __pyx_pyinit_module) return 0;
    PyErr_SetString(PyExc_RuntimeError, "Module 'SLEPc' has already been imported. Re-initialisation is not supported.");
    return -1;
  }
  #elif PY_MAJOR_VERSION >= 3
  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
  #endif
  #if CYTHON_REFNANNY
__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
if (!__Pyx_RefNanny) {
  PyErr_Clear();
  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
  if (!__Pyx_RefNanny)
      Py_FatalError("failed to import 'refnanny' module");
}
#endif
  __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_SLEPc(void)", 0);
  if (__Pyx_check_binary_version() < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  #ifdef __Pxy_PyFrame_Initialize_Offsets
  __Pxy_PyFrame_Initialize_Offsets();
  #endif
  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(23, 1, __pyx_L1_error)
  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(23, 1, __pyx_L1_error)
  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(23, 1, __pyx_L1_error)
  #ifdef __Pyx_CyFunction_USED
  if (__pyx_CyFunction_init() < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_FusedFunction_USED
  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_Coroutine_USED
  if (__pyx_Coroutine_init() < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_Generator_USED
  if (__pyx_Generator_init() < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_AsyncGen_USED
  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_StopAsyncIteration_USED
  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  #endif
  /*--- Library function declarations ---*/
  /*--- Threads initialization code ---*/
  #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
  PyEval_InitThreads();
  #endif
  /*--- Module creation code ---*/
  #if CYTHON_PEP489_MULTI_PHASE_INIT
  __pyx_m = __pyx_pyinit_module;
  Py_INCREF(__pyx_m);
  #else
  #if PY_MAJOR_VERSION < 3
  __pyx_m = Py_InitModule4("SLEPc", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
  #else
  __pyx_m = PyModule_Create(&__pyx_moduledef);
  #endif
  if (unlikely(!__pyx_m)) __PYX_ERR(23, 1, __pyx_L1_error)
  #endif
  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(23, 1, __pyx_L1_error)
  Py_INCREF(__pyx_d);
  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(23, 1, __pyx_L1_error)
  Py_INCREF(__pyx_b);
  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(23, 1, __pyx_L1_error)
  Py_INCREF(__pyx_cython_runtime);
  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(23, 1, __pyx_L1_error);
  /*--- Initialize various global constants etc. ---*/
  if (__Pyx_InitGlobals() < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  #endif
  if (__pyx_module_is_main_slepc4py__SLEPc) {
    if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  }
  #if PY_MAJOR_VERSION >= 3
  {
    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(23, 1, __pyx_L1_error)
    if (!PyDict_GetItemString(modules, "slepc4py.SLEPc")) {
      if (unlikely(PyDict_SetItemString(modules, "slepc4py.SLEPc", __pyx_m) < 0)) __PYX_ERR(23, 1, __pyx_L1_error)
    }
  }
  #endif
  /*--- Builtin init code ---*/
  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  /*--- Constants init code ---*/
  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  /*--- Global type/function init code ---*/
  (void)__Pyx_modinit_global_init_code();
  (void)__Pyx_modinit_variable_export_code();
  if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(23, 1, __pyx_L1_error)
  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(23, 1, __pyx_L1_error)
  if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(23, 1, __pyx_L1_error)
  (void)__Pyx_modinit_variable_import_code();
  if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(23, 1, __pyx_L1_error)
  /*--- Execution code ---*/
  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
  if (__Pyx_patch_abc() < 0) __PYX_ERR(23, 1, __pyx_L1_error)
  #endif

  /* "SLEPc/SLEPc.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * from petsc4py.PETSc import COMM_NULL             # <<<<<<<<<<<<<<
 * from petsc4py.PETSc import COMM_SELF
 * from petsc4py.PETSc import COMM_WORLD
 */
  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_n_s_COMM_NULL);
  __Pyx_GIVEREF(__pyx_n_s_COMM_NULL);
  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_COMM_NULL);
  __pyx_t_2 = __Pyx_Import(__pyx_n_s_petsc4py_PETSc, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_COMM_NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_COMM_NULL, __pyx_t_1) < 0) __PYX_ERR(4, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/SLEPc.pyx":4
 * 
 * from petsc4py.PETSc import COMM_NULL
 * from petsc4py.PETSc import COMM_SELF             # <<<<<<<<<<<<<<
 * from petsc4py.PETSc import COMM_WORLD
 * 
 */
  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_n_s_COMM_SELF);
  __Pyx_GIVEREF(__pyx_n_s_COMM_SELF);
  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_COMM_SELF);
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_petsc4py_PETSc, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_COMM_SELF); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_COMM_SELF, __pyx_t_2) < 0) __PYX_ERR(4, 4, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/SLEPc.pyx":5
 * from petsc4py.PETSc import COMM_NULL
 * from petsc4py.PETSc import COMM_SELF
 * from petsc4py.PETSc import COMM_WORLD             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_n_s_COMM_WORLD);
  __Pyx_GIVEREF(__pyx_n_s_COMM_WORLD);
  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_COMM_WORLD);
  __pyx_t_2 = __Pyx_Import(__pyx_n_s_petsc4py_PETSc, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_COMM_WORLD); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_COMM_WORLD, __pyx_t_1) < 0) __PYX_ERR(4, 5, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/SLEPc.pyx":62
 *     void *PyExc_RuntimeError
 * 
 * cdef object PetscError = <object>PyExc_RuntimeError             # <<<<<<<<<<<<<<
 * from petsc4py.PETSc import Error as PetscError
 * 
 */
  __pyx_t_2 = ((PyObject *)PyExc_RuntimeError);
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_XGOTREF(__pyx_v_8slepc4py_5SLEPc_PetscError);
  __Pyx_DECREF_SET(__pyx_v_8slepc4py_5SLEPc_PetscError, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __pyx_t_2 = 0;

  /* "SLEPc/SLEPc.pyx":63
 * 
 * cdef object PetscError = <object>PyExc_RuntimeError
 * from petsc4py.PETSc import Error as PetscError             # <<<<<<<<<<<<<<
 * 
 * cdef inline int SETERR(int ierr) with gil:
 */
  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 63, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_n_s_Error);
  __Pyx_GIVEREF(__pyx_n_s_Error);
  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_Error);
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_petsc4py_PETSc, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 63, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 63, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_t_2);
  __Pyx_XGOTREF(__pyx_v_8slepc4py_5SLEPc_PetscError);
  __Pyx_DECREF_SET(__pyx_v_8slepc4py_5SLEPc_PetscError, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/SLEPc.pyx":133
 * include "arraynpy.pxi"
 * 
 * import_array()             # <<<<<<<<<<<<<<
 * 
 * IntType     = PyArray_TypeObjectFromType(NPY_PETSC_INT)
 */
  __pyx_t_3 = _import_array(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(4, 133, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":135
 * import_array()
 * 
 * IntType     = PyArray_TypeObjectFromType(NPY_PETSC_INT)             # <<<<<<<<<<<<<<
 * RealType    = PyArray_TypeObjectFromType(NPY_PETSC_REAL)
 * ScalarType  = PyArray_TypeObjectFromType(NPY_PETSC_SCALAR)
 */
  __pyx_t_1 = PyArray_TypeObjectFromType(NPY_PETSC_INT); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 135, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_IntType, __pyx_t_1) < 0) __PYX_ERR(4, 135, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/SLEPc.pyx":136
 * 
 * IntType     = PyArray_TypeObjectFromType(NPY_PETSC_INT)
 * RealType    = PyArray_TypeObjectFromType(NPY_PETSC_REAL)             # <<<<<<<<<<<<<<
 * ScalarType  = PyArray_TypeObjectFromType(NPY_PETSC_SCALAR)
 * ComplexType = PyArray_TypeObjectFromType(NPY_PETSC_COMPLEX)
 */
  __pyx_t_1 = PyArray_TypeObjectFromType(NPY_PETSC_REAL); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 136, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_RealType, __pyx_t_1) < 0) __PYX_ERR(4, 136, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/SLEPc.pyx":137
 * IntType     = PyArray_TypeObjectFromType(NPY_PETSC_INT)
 * RealType    = PyArray_TypeObjectFromType(NPY_PETSC_REAL)
 * ScalarType  = PyArray_TypeObjectFromType(NPY_PETSC_SCALAR)             # <<<<<<<<<<<<<<
 * ComplexType = PyArray_TypeObjectFromType(NPY_PETSC_COMPLEX)
 * 
 */
  __pyx_t_1 = PyArray_TypeObjectFromType(NPY_PETSC_SCALAR); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 137, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ScalarType, __pyx_t_1) < 0) __PYX_ERR(4, 137, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/SLEPc.pyx":138
 * RealType    = PyArray_TypeObjectFromType(NPY_PETSC_REAL)
 * ScalarType  = PyArray_TypeObjectFromType(NPY_PETSC_SCALAR)
 * ComplexType = PyArray_TypeObjectFromType(NPY_PETSC_COMPLEX)             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_1 = PyArray_TypeObjectFromType(NPY_PETSC_COMPLEX); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 138, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ComplexType, __pyx_t_1) < 0) __PYX_ERR(4, 138, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/SLEPc.pyx":164
 * # -----------------------------------------------------------------------------
 * 
 * __doc__ = u"""             # <<<<<<<<<<<<<<
 * Scalable Library for Eigenvalue Problem Computations
 * """
 */
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_doc, __pyx_kp_u_Scalable_Library_for_Eigenvalue) < 0) __PYX_ERR(4, 164, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":168
 * """
 * 
 * DECIDE    = PETSC_DECIDE             # <<<<<<<<<<<<<<
 * DEFAULT   = PETSC_DEFAULT
 * DETERMINE = PETSC_DETERMINE
 */
  __pyx_t_1 = __Pyx_PyInt_From_int(PETSC_DECIDE); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 168, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DECIDE, __pyx_t_1) < 0) __PYX_ERR(4, 168, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/SLEPc.pyx":169
 * 
 * DECIDE    = PETSC_DECIDE
 * DEFAULT   = PETSC_DEFAULT             # <<<<<<<<<<<<<<
 * DETERMINE = PETSC_DETERMINE
 * 
 */
  __pyx_t_1 = __Pyx_PyInt_From_int(PETSC_DEFAULT); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 169, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DEFAULT, __pyx_t_1) < 0) __PYX_ERR(4, 169, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/SLEPc.pyx":170
 * DECIDE    = PETSC_DECIDE
 * DEFAULT   = PETSC_DEFAULT
 * DETERMINE = PETSC_DETERMINE             # <<<<<<<<<<<<<<
 * 
 * include "Sys.pyx"
 */
  __pyx_t_1 = __Pyx_PyInt_From_int(PETSC_DETERMINE); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 170, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DETERMINE, __pyx_t_1) < 0) __PYX_ERR(4, 170, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "SLEPc/Sys.pyx":6
 * 
 *     @classmethod
 *     def getVersion(cls, devel=False, date=False, author=False):             # <<<<<<<<<<<<<<
 *         cdef char cversion[256]
 *         cdef PetscInt major=0, minor=0, micro=0, release=0
 */
  __Pyx_GetNameInClass(__pyx_t_1, (PyObject *)__pyx_ptype_8slepc4py_5SLEPc_Sys, __pyx_n_s_getVersion); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/Sys.pyx":5
 * cdef class Sys:
 * 
 *     @classmethod             # <<<<<<<<<<<<<<
 *     def getVersion(cls, devel=False, date=False, author=False):
 *         cdef char cversion[256]
 */
  __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 5, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_Sys->tp_dict, __pyx_n_s_getVersion, __pyx_t_2) < 0) __PYX_ERR(12, 6, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_Sys);

  /* "SLEPc/Sys.pyx":30
 * 
 *     @classmethod
 *     def getVersionInfo(cls):             # <<<<<<<<<<<<<<
 *         version, dev, date, author = cls.getVersion(True, True, True)
 *         return dict(major      = version[0],
 */
  __Pyx_GetNameInClass(__pyx_t_2, (PyObject *)__pyx_ptype_8slepc4py_5SLEPc_Sys, __pyx_n_s_getVersionInfo); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 30, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);

  /* "SLEPc/Sys.pyx":29
 *         return tuple(out)
 * 
 *     @classmethod             # <<<<<<<<<<<<<<
 *     def getVersionInfo(cls):
 *         version, dev, date, author = cls.getVersion(True, True, True)
 */
  __pyx_t_1 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 29, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_Sys->tp_dict, __pyx_n_s_getVersionInfo, __pyx_t_1) < 0) __PYX_ERR(12, 30, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_Sys);

  /* "SLEPc/Sys.pyx":42
 * 
 *     @classmethod
 *     def isInitialized(cls):             # <<<<<<<<<<<<<<
 *         return toBool(SlepcInitializeCalled)
 * 
 */
  __Pyx_GetNameInClass(__pyx_t_1, (PyObject *)__pyx_ptype_8slepc4py_5SLEPc_Sys, __pyx_n_s_isInitialized); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 42, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/Sys.pyx":41
 *     # --- xxx ---
 * 
 *     @classmethod             # <<<<<<<<<<<<<<
 *     def isInitialized(cls):
 *         return toBool(SlepcInitializeCalled)
 */
  __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 41, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_Sys->tp_dict, __pyx_n_s_isInitialized, __pyx_t_2) < 0) __PYX_ERR(12, 42, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_Sys);

  /* "SLEPc/Sys.pyx":46
 * 
 *     @classmethod
 *     def isFinalized(cls):             # <<<<<<<<<<<<<<
 *         return toBool(SlepcFinalizeCalled)
 * 
 */
  __Pyx_GetNameInClass(__pyx_t_2, (PyObject *)__pyx_ptype_8slepc4py_5SLEPc_Sys, __pyx_n_s_isFinalized); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 46, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);

  /* "SLEPc/Sys.pyx":45
 *         return toBool(SlepcInitializeCalled)
 * 
 *     @classmethod             # <<<<<<<<<<<<<<
 *     def isFinalized(cls):
 *         return toBool(SlepcFinalizeCalled)
 */
  __pyx_t_1 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 45, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_Sys->tp_dict, __pyx_n_s_isFinalized, __pyx_t_1) < 0) __PYX_ERR(12, 46, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_Sys);

  /* "SLEPc/Sys.pyx":52
 * 
 *     @classmethod
 *     def hasExternalPackage(cls, package):             # <<<<<<<<<<<<<<
 *         cdef const char *cpackage = NULL
 *         package = str2bytes(package, &cpackage)
 */
  __Pyx_GetNameInClass(__pyx_t_1, (PyObject *)__pyx_ptype_8slepc4py_5SLEPc_Sys, __pyx_n_s_hasExternalPackage); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/Sys.pyx":51
 *     # --- xxx ---
 * 
 *     @classmethod             # <<<<<<<<<<<<<<
 *     def hasExternalPackage(cls, package):
 *         cdef const char *cpackage = NULL
 */
  __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_Sys->tp_dict, __pyx_n_s_hasExternalPackage, __pyx_t_2) < 0) __PYX_ERR(12, 52, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_Sys);

  /* "SLEPc/ST.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class STType(object):             # <<<<<<<<<<<<<<
 *     """
 *     ST types
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__6, __pyx_n_s_STType, __pyx_n_s_STType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_ST_types_SHELL_User_defined_SHI); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/ST.pyx":14
 *     - `FILTER`:  Polynomial filter.
 *     """
 *     SHELL   = S_(STSHELL)             # <<<<<<<<<<<<<<
 *     SHIFT   = S_(STSHIFT)
 *     SINVERT = S_(STSINVERT)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(STSHELL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 14, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SHELL, __pyx_t_4) < 0) __PYX_ERR(0, 14, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/ST.pyx":15
 *     """
 *     SHELL   = S_(STSHELL)
 *     SHIFT   = S_(STSHIFT)             # <<<<<<<<<<<<<<
 *     SINVERT = S_(STSINVERT)
 *     CAYLEY  = S_(STCAYLEY)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(STSHIFT); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SHIFT, __pyx_t_4) < 0) __PYX_ERR(0, 15, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/ST.pyx":16
 *     SHELL   = S_(STSHELL)
 *     SHIFT   = S_(STSHIFT)
 *     SINVERT = S_(STSINVERT)             # <<<<<<<<<<<<<<
 *     CAYLEY  = S_(STCAYLEY)
 *     PRECOND = S_(STPRECOND)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(STSINVERT); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SINVERT, __pyx_t_4) < 0) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/ST.pyx":17
 *     SHIFT   = S_(STSHIFT)
 *     SINVERT = S_(STSINVERT)
 *     CAYLEY  = S_(STCAYLEY)             # <<<<<<<<<<<<<<
 *     PRECOND = S_(STPRECOND)
 *     FILTER  = S_(STFILTER)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(STCAYLEY); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CAYLEY, __pyx_t_4) < 0) __PYX_ERR(0, 17, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/ST.pyx":18
 *     SINVERT = S_(STSINVERT)
 *     CAYLEY  = S_(STCAYLEY)
 *     PRECOND = S_(STPRECOND)             # <<<<<<<<<<<<<<
 *     FILTER  = S_(STFILTER)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(STPRECOND); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_PRECOND, __pyx_t_4) < 0) __PYX_ERR(0, 18, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/ST.pyx":19
 *     CAYLEY  = S_(STCAYLEY)
 *     PRECOND = S_(STPRECOND)
 *     FILTER  = S_(STFILTER)             # <<<<<<<<<<<<<<
 * 
 * class STMatMode(object):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(STFILTER); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 19, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_FILTER, __pyx_t_4) < 0) __PYX_ERR(0, 19, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/ST.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class STType(object):             # <<<<<<<<<<<<<<
 *     """
 *     ST types
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_STType, __pyx_tuple__6, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_STType, __pyx_t_4) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/ST.pyx":21
 *     FILTER  = S_(STFILTER)
 * 
 * class STMatMode(object):             # <<<<<<<<<<<<<<
 *     """
 *     ST matrix mode
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__7, __pyx_n_s_STMatMode, __pyx_n_s_STMatMode, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_ST_matrix_mode_COPY_A_working_c); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/ST.pyx":30
 *       implicit matrix.
 *     """
 *     COPY    = ST_MATMODE_COPY             # <<<<<<<<<<<<<<
 *     INPLACE = ST_MATMODE_INPLACE
 *     SHELL   = ST_MATMODE_SHELL
 */
  __pyx_t_4 = __Pyx_PyInt_From_STMatMode(ST_MATMODE_COPY); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 30, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_COPY, __pyx_t_4) < 0) __PYX_ERR(0, 30, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/ST.pyx":31
 *     """
 *     COPY    = ST_MATMODE_COPY
 *     INPLACE = ST_MATMODE_INPLACE             # <<<<<<<<<<<<<<
 *     SHELL   = ST_MATMODE_SHELL
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_STMatMode(ST_MATMODE_INPLACE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 31, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_INPLACE, __pyx_t_4) < 0) __PYX_ERR(0, 31, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/ST.pyx":32
 *     COPY    = ST_MATMODE_COPY
 *     INPLACE = ST_MATMODE_INPLACE
 *     SHELL   = ST_MATMODE_SHELL             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_4 = __Pyx_PyInt_From_STMatMode(ST_MATMODE_SHELL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 32, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SHELL, __pyx_t_4) < 0) __PYX_ERR(0, 32, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/ST.pyx":21
 *     FILTER  = S_(STFILTER)
 * 
 * class STMatMode(object):             # <<<<<<<<<<<<<<
 *     """
 *     ST matrix mode
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_STMatMode, __pyx_tuple__7, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 21, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_STMatMode, __pyx_t_4) < 0) __PYX_ERR(0, 21, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/ST.pyx":42
 *     """
 * 
 *     Type         = STType             # <<<<<<<<<<<<<<
 *     MatMode      = STMatMode
 * 
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_STType); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_ST->tp_dict, __pyx_n_s_Type, __pyx_t_2) < 0) __PYX_ERR(0, 42, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_ST);

  /* "SLEPc/ST.pyx":43
 * 
 *     Type         = STType
 *     MatMode      = STMatMode             # <<<<<<<<<<<<<<
 * 
 *     def __cinit__(self):
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_STMatMode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 43, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_ST->tp_dict, __pyx_n_s_MatMode, __pyx_t_2) < 0) __PYX_ERR(0, 43, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_ST);

  /* "SLEPc/ST.pyx":698
 * # -----------------------------------------------------------------------------
 * 
 * del STType             # <<<<<<<<<<<<<<
 * del STMatMode
 * 
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_STType) < 0) __PYX_ERR(0, 698, __pyx_L1_error)

  /* "SLEPc/ST.pyx":699
 * 
 * del STType
 * del STMatMode             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_STMatMode) < 0) __PYX_ERR(0, 699, __pyx_L1_error)

  /* "SLEPc/BV.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class BVType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV type
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__8); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__8, __pyx_n_s_BVType, __pyx_n_s_BVType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_BV_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/BV.pyx":7
 *     BV type
 *     """
 *     MAT        = S_(BVMAT)             # <<<<<<<<<<<<<<
 *     SVEC       = S_(BVSVEC)
 *     VECS       = S_(BVVECS)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(BVMAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 7, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_MAT, __pyx_t_4) < 0) __PYX_ERR(13, 7, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":8
 *     """
 *     MAT        = S_(BVMAT)
 *     SVEC       = S_(BVSVEC)             # <<<<<<<<<<<<<<
 *     VECS       = S_(BVVECS)
 *     CONTIGUOUS = S_(BVCONTIGUOUS)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(BVSVEC); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 8, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SVEC, __pyx_t_4) < 0) __PYX_ERR(13, 8, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":9
 *     MAT        = S_(BVMAT)
 *     SVEC       = S_(BVSVEC)
 *     VECS       = S_(BVVECS)             # <<<<<<<<<<<<<<
 *     CONTIGUOUS = S_(BVCONTIGUOUS)
 *     TENSOR     = S_(BVTENSOR)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(BVVECS); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_VECS, __pyx_t_4) < 0) __PYX_ERR(13, 9, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":10
 *     SVEC       = S_(BVSVEC)
 *     VECS       = S_(BVVECS)
 *     CONTIGUOUS = S_(BVCONTIGUOUS)             # <<<<<<<<<<<<<<
 *     TENSOR     = S_(BVTENSOR)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(BVCONTIGUOUS); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 10, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONTIGUOUS, __pyx_t_4) < 0) __PYX_ERR(13, 10, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":11
 *     VECS       = S_(BVVECS)
 *     CONTIGUOUS = S_(BVCONTIGUOUS)
 *     TENSOR     = S_(BVTENSOR)             # <<<<<<<<<<<<<<
 * 
 * class BVOrthogType(object):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(BVTENSOR); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 11, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TENSOR, __pyx_t_4) < 0) __PYX_ERR(13, 11, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class BVType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV type
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_BVType, __pyx_tuple__8, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BVType, __pyx_t_4) < 0) __PYX_ERR(13, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/BV.pyx":13
 *     TENSOR     = S_(BVTENSOR)
 * 
 * class BVOrthogType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV orthogonalization types
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__9); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__9, __pyx_n_s_BVOrthogType, __pyx_n_s_BVOrthogType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_BV_orthogonalization_types_CGS); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/BV.pyx":20
 *     - `MGS`: Modified Gram-Schmidt.
 *     """
 *     CGS = BV_ORTHOG_CGS             # <<<<<<<<<<<<<<
 *     MGS = BV_ORTHOG_MGS
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVOrthogType(BV_ORTHOG_CGS); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 20, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CGS, __pyx_t_4) < 0) __PYX_ERR(13, 20, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":21
 *     """
 *     CGS = BV_ORTHOG_CGS
 *     MGS = BV_ORTHOG_MGS             # <<<<<<<<<<<<<<
 * 
 * class BVOrthogRefineType(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVOrthogType(BV_ORTHOG_MGS); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 21, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_MGS, __pyx_t_4) < 0) __PYX_ERR(13, 21, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":13
 *     TENSOR     = S_(BVTENSOR)
 * 
 * class BVOrthogType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV orthogonalization types
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_BVOrthogType, __pyx_tuple__9, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BVOrthogType, __pyx_t_4) < 0) __PYX_ERR(13, 13, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/BV.pyx":23
 *     MGS = BV_ORTHOG_MGS
 * 
 * class BVOrthogRefineType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV orthogonalization refinement types
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__10); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__10, __pyx_n_s_BVOrthogRefineType, __pyx_n_s_BVOrthogRefineType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_BV_orthogonalization_refinement); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/BV.pyx":31
 *     - `ALWAYS`:   Always reorthogonalize.
 *     """
 *     IFNEEDED = BV_ORTHOG_REFINE_IFNEEDED             # <<<<<<<<<<<<<<
 *     NEVER    = BV_ORTHOG_REFINE_NEVER
 *     ALWAYS   = BV_ORTHOG_REFINE_ALWAYS
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVOrthogRefineType(BV_ORTHOG_REFINE_IFNEEDED); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 31, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_IFNEEDED, __pyx_t_4) < 0) __PYX_ERR(13, 31, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":32
 *     """
 *     IFNEEDED = BV_ORTHOG_REFINE_IFNEEDED
 *     NEVER    = BV_ORTHOG_REFINE_NEVER             # <<<<<<<<<<<<<<
 *     ALWAYS   = BV_ORTHOG_REFINE_ALWAYS
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVOrthogRefineType(BV_ORTHOG_REFINE_NEVER); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 32, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NEVER, __pyx_t_4) < 0) __PYX_ERR(13, 32, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":33
 *     IFNEEDED = BV_ORTHOG_REFINE_IFNEEDED
 *     NEVER    = BV_ORTHOG_REFINE_NEVER
 *     ALWAYS   = BV_ORTHOG_REFINE_ALWAYS             # <<<<<<<<<<<<<<
 * 
 * class BVOrthogBlockType(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVOrthogRefineType(BV_ORTHOG_REFINE_ALWAYS); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 33, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ALWAYS, __pyx_t_4) < 0) __PYX_ERR(13, 33, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":23
 *     MGS = BV_ORTHOG_MGS
 * 
 * class BVOrthogRefineType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV orthogonalization refinement types
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_BVOrthogRefineType, __pyx_tuple__10, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BVOrthogRefineType, __pyx_t_4) < 0) __PYX_ERR(13, 23, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/BV.pyx":35
 *     ALWAYS   = BV_ORTHOG_REFINE_ALWAYS
 * 
 * class BVOrthogBlockType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV block-orthogonalization types
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__11); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 35, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__11, __pyx_n_s_BVOrthogBlockType, __pyx_n_s_BVOrthogBlockType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_BV_block_orthogonalization_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 35, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/BV.pyx":45
 *     - `SVQB`:     SVQB.
 *     """
 *     GS       = BV_ORTHOG_BLOCK_GS             # <<<<<<<<<<<<<<
 *     CHOL     = BV_ORTHOG_BLOCK_CHOL
 *     TSQR     = BV_ORTHOG_BLOCK_TSQR
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVOrthogBlockType(BV_ORTHOG_BLOCK_GS); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 45, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_GS, __pyx_t_4) < 0) __PYX_ERR(13, 45, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":46
 *     """
 *     GS       = BV_ORTHOG_BLOCK_GS
 *     CHOL     = BV_ORTHOG_BLOCK_CHOL             # <<<<<<<<<<<<<<
 *     TSQR     = BV_ORTHOG_BLOCK_TSQR
 *     TSQRCHOL = BV_ORTHOG_BLOCK_TSQRCHOL
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVOrthogBlockType(BV_ORTHOG_BLOCK_CHOL); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 46, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CHOL, __pyx_t_4) < 0) __PYX_ERR(13, 46, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":47
 *     GS       = BV_ORTHOG_BLOCK_GS
 *     CHOL     = BV_ORTHOG_BLOCK_CHOL
 *     TSQR     = BV_ORTHOG_BLOCK_TSQR             # <<<<<<<<<<<<<<
 *     TSQRCHOL = BV_ORTHOG_BLOCK_TSQRCHOL
 *     SVQB     = BV_ORTHOG_BLOCK_SVQB
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVOrthogBlockType(BV_ORTHOG_BLOCK_TSQR); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 47, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TSQR, __pyx_t_4) < 0) __PYX_ERR(13, 47, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":48
 *     CHOL     = BV_ORTHOG_BLOCK_CHOL
 *     TSQR     = BV_ORTHOG_BLOCK_TSQR
 *     TSQRCHOL = BV_ORTHOG_BLOCK_TSQRCHOL             # <<<<<<<<<<<<<<
 *     SVQB     = BV_ORTHOG_BLOCK_SVQB
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVOrthogBlockType(BV_ORTHOG_BLOCK_TSQRCHOL); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 48, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TSQRCHOL, __pyx_t_4) < 0) __PYX_ERR(13, 48, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":49
 *     TSQR     = BV_ORTHOG_BLOCK_TSQR
 *     TSQRCHOL = BV_ORTHOG_BLOCK_TSQRCHOL
 *     SVQB     = BV_ORTHOG_BLOCK_SVQB             # <<<<<<<<<<<<<<
 * 
 * class BVMatMultType(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVOrthogBlockType(BV_ORTHOG_BLOCK_SVQB); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SVQB, __pyx_t_4) < 0) __PYX_ERR(13, 49, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":35
 *     ALWAYS   = BV_ORTHOG_REFINE_ALWAYS
 * 
 * class BVOrthogBlockType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV block-orthogonalization types
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_BVOrthogBlockType, __pyx_tuple__11, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 35, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BVOrthogBlockType, __pyx_t_4) < 0) __PYX_ERR(13, 35, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/BV.pyx":51
 *     SVQB     = BV_ORTHOG_BLOCK_SVQB
 * 
 * class BVMatMultType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV mat-mult types
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__12); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__12, __pyx_n_s_BVMatMultType, __pyx_n_s_BVMatMultType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_BV_mat_mult_types_VECS_Perform); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/BV.pyx":58
 *     - `MAT`:  Carry out a Mat-Mat product with a dense matrix.
 *     """
 *     VECS     = BV_MATMULT_VECS             # <<<<<<<<<<<<<<
 *     MAT      = BV_MATMULT_MAT
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVMatMultType(BV_MATMULT_VECS); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 58, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_VECS, __pyx_t_4) < 0) __PYX_ERR(13, 58, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":59
 *     """
 *     VECS     = BV_MATMULT_VECS
 *     MAT      = BV_MATMULT_MAT             # <<<<<<<<<<<<<<
 * 
 * class BVSVDMethod(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVMatMultType(BV_MATMULT_MAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 59, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_MAT, __pyx_t_4) < 0) __PYX_ERR(13, 59, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":51
 *     SVQB     = BV_ORTHOG_BLOCK_SVQB
 * 
 * class BVMatMultType(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV mat-mult types
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_BVMatMultType, __pyx_tuple__12, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BVMatMultType, __pyx_t_4) < 0) __PYX_ERR(13, 51, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/BV.pyx":61
 *     MAT      = BV_MATMULT_MAT
 * 
 * class BVSVDMethod(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV methods for computing the SVD
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__13); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__13, __pyx_n_s_BVSVDMethod, __pyx_n_s_BVSVDMethod, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_BV_methods_for_computing_the_SV); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/BV.pyx":69
 *     - `QR_CAA`: Variant of QR intended for use in cammunication-avoiding Arnoldi.
 *     """
 *     REFINE   = BV_SVD_METHOD_REFINE             # <<<<<<<<<<<<<<
 *     QR       = BV_SVD_METHOD_QR
 *     QR_CAA   = BV_SVD_METHOD_QR_CAA
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVSVDMethod(BV_SVD_METHOD_REFINE); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 69, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_REFINE, __pyx_t_4) < 0) __PYX_ERR(13, 69, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":70
 *     """
 *     REFINE   = BV_SVD_METHOD_REFINE
 *     QR       = BV_SVD_METHOD_QR             # <<<<<<<<<<<<<<
 *     QR_CAA   = BV_SVD_METHOD_QR_CAA
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVSVDMethod(BV_SVD_METHOD_QR); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 70, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_QR, __pyx_t_4) < 0) __PYX_ERR(13, 70, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":71
 *     REFINE   = BV_SVD_METHOD_REFINE
 *     QR       = BV_SVD_METHOD_QR
 *     QR_CAA   = BV_SVD_METHOD_QR_CAA             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_4 = __Pyx_PyInt_From_BVSVDMethod(BV_SVD_METHOD_QR_CAA); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 71, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_QR_CAA, __pyx_t_4) < 0) __PYX_ERR(13, 71, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/BV.pyx":61
 *     MAT      = BV_MATMULT_MAT
 * 
 * class BVSVDMethod(object):             # <<<<<<<<<<<<<<
 *     """
 *     BV methods for computing the SVD
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_BVSVDMethod, __pyx_tuple__13, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BVSVDMethod, __pyx_t_4) < 0) __PYX_ERR(13, 61, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/BV.pyx":81
 *     """
 * 
 *     Type             = BVType             # <<<<<<<<<<<<<<
 *     OrthogType       = BVOrthogType
 *     OrthogRefineType = BVOrthogRefineType
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BVType); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 81, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV->tp_dict, __pyx_n_s_Type, __pyx_t_2) < 0) __PYX_ERR(13, 81, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_BV);

  /* "SLEPc/BV.pyx":82
 * 
 *     Type             = BVType
 *     OrthogType       = BVOrthogType             # <<<<<<<<<<<<<<
 *     OrthogRefineType = BVOrthogRefineType
 *     RefineType       = BVOrthogRefineType
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BVOrthogType); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 82, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV->tp_dict, __pyx_n_s_OrthogType, __pyx_t_2) < 0) __PYX_ERR(13, 82, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_BV);

  /* "SLEPc/BV.pyx":83
 *     Type             = BVType
 *     OrthogType       = BVOrthogType
 *     OrthogRefineType = BVOrthogRefineType             # <<<<<<<<<<<<<<
 *     RefineType       = BVOrthogRefineType
 *     OrthogBlockType  = BVOrthogBlockType
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BVOrthogRefineType); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 83, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV->tp_dict, __pyx_n_s_OrthogRefineType, __pyx_t_2) < 0) __PYX_ERR(13, 83, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_BV);

  /* "SLEPc/BV.pyx":84
 *     OrthogType       = BVOrthogType
 *     OrthogRefineType = BVOrthogRefineType
 *     RefineType       = BVOrthogRefineType             # <<<<<<<<<<<<<<
 *     OrthogBlockType  = BVOrthogBlockType
 *     BlockType        = BVOrthogBlockType
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BVOrthogRefineType); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 84, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV->tp_dict, __pyx_n_s_RefineType, __pyx_t_2) < 0) __PYX_ERR(13, 84, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_BV);

  /* "SLEPc/BV.pyx":85
 *     OrthogRefineType = BVOrthogRefineType
 *     RefineType       = BVOrthogRefineType
 *     OrthogBlockType  = BVOrthogBlockType             # <<<<<<<<<<<<<<
 *     BlockType        = BVOrthogBlockType
 *     MatMultType      = BVMatMultType
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BVOrthogBlockType); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 85, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV->tp_dict, __pyx_n_s_OrthogBlockType, __pyx_t_2) < 0) __PYX_ERR(13, 85, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_BV);

  /* "SLEPc/BV.pyx":86
 *     RefineType       = BVOrthogRefineType
 *     OrthogBlockType  = BVOrthogBlockType
 *     BlockType        = BVOrthogBlockType             # <<<<<<<<<<<<<<
 *     MatMultType      = BVMatMultType
 * 
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BVOrthogBlockType); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 86, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV->tp_dict, __pyx_n_s_BlockType, __pyx_t_2) < 0) __PYX_ERR(13, 86, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_BV);

  /* "SLEPc/BV.pyx":87
 *     OrthogBlockType  = BVOrthogBlockType
 *     BlockType        = BVOrthogBlockType
 *     MatMultType      = BVMatMultType             # <<<<<<<<<<<<<<
 * 
 *     def __cinit__(self):
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_BVMatMultType); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 87, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_BV->tp_dict, __pyx_n_s_MatMultType, __pyx_t_2) < 0) __PYX_ERR(13, 87, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_BV);

  /* "SLEPc/BV.pyx":1400
 * # -----------------------------------------------------------------------------
 * 
 * del BVType             # <<<<<<<<<<<<<<
 * del BVOrthogType
 * del BVOrthogRefineType
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_BVType) < 0) __PYX_ERR(13, 1400, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1401
 * 
 * del BVType
 * del BVOrthogType             # <<<<<<<<<<<<<<
 * del BVOrthogRefineType
 * del BVOrthogBlockType
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_BVOrthogType) < 0) __PYX_ERR(13, 1401, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1402
 * del BVType
 * del BVOrthogType
 * del BVOrthogRefineType             # <<<<<<<<<<<<<<
 * del BVOrthogBlockType
 * del BVMatMultType
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_BVOrthogRefineType) < 0) __PYX_ERR(13, 1402, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1403
 * del BVOrthogType
 * del BVOrthogRefineType
 * del BVOrthogBlockType             # <<<<<<<<<<<<<<
 * del BVMatMultType
 * 
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_BVOrthogBlockType) < 0) __PYX_ERR(13, 1403, __pyx_L1_error)

  /* "SLEPc/BV.pyx":1404
 * del BVOrthogRefineType
 * del BVOrthogBlockType
 * del BVMatMultType             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_BVMatMultType) < 0) __PYX_ERR(13, 1404, __pyx_L1_error)

  /* "SLEPc/DS.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class DSType(object):             # <<<<<<<<<<<<<<
 *     """
 *     DS type
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__14); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__14, __pyx_n_s_DSType, __pyx_n_s_DSType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_DS_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/DS.pyx":7
 *     DS type
 *     """
 *     HEP     = S_(DSHEP)             # <<<<<<<<<<<<<<
 *     NHEP    = S_(DSNHEP)
 *     GHEP    = S_(DSGHEP)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(DSHEP); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 7, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_HEP, __pyx_t_4) < 0) __PYX_ERR(14, 7, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":8
 *     """
 *     HEP     = S_(DSHEP)
 *     NHEP    = S_(DSNHEP)             # <<<<<<<<<<<<<<
 *     GHEP    = S_(DSGHEP)
 *     GHIEP   = S_(DSGHIEP)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(DSNHEP); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 8, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NHEP, __pyx_t_4) < 0) __PYX_ERR(14, 8, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":9
 *     HEP     = S_(DSHEP)
 *     NHEP    = S_(DSNHEP)
 *     GHEP    = S_(DSGHEP)             # <<<<<<<<<<<<<<
 *     GHIEP   = S_(DSGHIEP)
 *     GNHEP   = S_(DSGNHEP)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(DSGHEP); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_GHEP, __pyx_t_4) < 0) __PYX_ERR(14, 9, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":10
 *     NHEP    = S_(DSNHEP)
 *     GHEP    = S_(DSGHEP)
 *     GHIEP   = S_(DSGHIEP)             # <<<<<<<<<<<<<<
 *     GNHEP   = S_(DSGNHEP)
 *     NHEPTS  = S_(DSNHEPTS)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(DSGHIEP); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 10, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_GHIEP, __pyx_t_4) < 0) __PYX_ERR(14, 10, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":11
 *     GHEP    = S_(DSGHEP)
 *     GHIEP   = S_(DSGHIEP)
 *     GNHEP   = S_(DSGNHEP)             # <<<<<<<<<<<<<<
 *     NHEPTS  = S_(DSNHEPTS)
 *     SVD     = S_(DSSVD)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(DSGNHEP); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 11, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_GNHEP, __pyx_t_4) < 0) __PYX_ERR(14, 11, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":12
 *     GHIEP   = S_(DSGHIEP)
 *     GNHEP   = S_(DSGNHEP)
 *     NHEPTS  = S_(DSNHEPTS)             # <<<<<<<<<<<<<<
 *     SVD     = S_(DSSVD)
 *     GSVD    = S_(DSGSVD)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(DSNHEPTS); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 12, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NHEPTS, __pyx_t_4) < 0) __PYX_ERR(14, 12, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":13
 *     GNHEP   = S_(DSGNHEP)
 *     NHEPTS  = S_(DSNHEPTS)
 *     SVD     = S_(DSSVD)             # <<<<<<<<<<<<<<
 *     GSVD    = S_(DSGSVD)
 *     PEP     = S_(DSPEP)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(DSSVD); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SVD, __pyx_t_4) < 0) __PYX_ERR(14, 13, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":14
 *     NHEPTS  = S_(DSNHEPTS)
 *     SVD     = S_(DSSVD)
 *     GSVD    = S_(DSGSVD)             # <<<<<<<<<<<<<<
 *     PEP     = S_(DSPEP)
 *     NEP     = S_(DSNEP)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(DSGSVD); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 14, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_GSVD, __pyx_t_4) < 0) __PYX_ERR(14, 14, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":15
 *     SVD     = S_(DSSVD)
 *     GSVD    = S_(DSGSVD)
 *     PEP     = S_(DSPEP)             # <<<<<<<<<<<<<<
 *     NEP     = S_(DSNEP)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(DSPEP); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_PEP, __pyx_t_4) < 0) __PYX_ERR(14, 15, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":16
 *     GSVD    = S_(DSGSVD)
 *     PEP     = S_(DSPEP)
 *     NEP     = S_(DSNEP)             # <<<<<<<<<<<<<<
 * 
 * class DSStateType(object):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(DSNEP); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 16, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NEP, __pyx_t_4) < 0) __PYX_ERR(14, 16, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class DSType(object):             # <<<<<<<<<<<<<<
 *     """
 *     DS type
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_DSType, __pyx_tuple__14, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DSType, __pyx_t_4) < 0) __PYX_ERR(14, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/DS.pyx":18
 *     NEP     = S_(DSNEP)
 * 
 * class DSStateType(object):             # <<<<<<<<<<<<<<
 *     """
 *     DS state types
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__15); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__15, __pyx_n_s_DSStateType, __pyx_n_s_DSStateType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_DS_state_types_RAW_Not_processe); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/DS.pyx":27
 *     - `TRUNCATED`:    Condensed form truncated to a smaller size.
 *     """
 *     RAW          = DS_STATE_RAW             # <<<<<<<<<<<<<<
 *     INTERMEDIATE = DS_STATE_INTERMEDIATE
 *     CONDENSED    = DS_STATE_CONDENSED
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSStateType(DS_STATE_RAW); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 27, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RAW, __pyx_t_4) < 0) __PYX_ERR(14, 27, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":28
 *     """
 *     RAW          = DS_STATE_RAW
 *     INTERMEDIATE = DS_STATE_INTERMEDIATE             # <<<<<<<<<<<<<<
 *     CONDENSED    = DS_STATE_CONDENSED
 *     TRUNCATED    = DS_STATE_TRUNCATED
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSStateType(DS_STATE_INTERMEDIATE); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 28, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_INTERMEDIATE, __pyx_t_4) < 0) __PYX_ERR(14, 28, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":29
 *     RAW          = DS_STATE_RAW
 *     INTERMEDIATE = DS_STATE_INTERMEDIATE
 *     CONDENSED    = DS_STATE_CONDENSED             # <<<<<<<<<<<<<<
 *     TRUNCATED    = DS_STATE_TRUNCATED
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSStateType(DS_STATE_CONDENSED); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 29, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONDENSED, __pyx_t_4) < 0) __PYX_ERR(14, 29, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":30
 *     INTERMEDIATE = DS_STATE_INTERMEDIATE
 *     CONDENSED    = DS_STATE_CONDENSED
 *     TRUNCATED    = DS_STATE_TRUNCATED             # <<<<<<<<<<<<<<
 * 
 * class DSMatType(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSStateType(DS_STATE_TRUNCATED); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 30, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TRUNCATED, __pyx_t_4) < 0) __PYX_ERR(14, 30, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":18
 *     NEP     = S_(DSNEP)
 * 
 * class DSStateType(object):             # <<<<<<<<<<<<<<
 *     """
 *     DS state types
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_DSStateType, __pyx_tuple__15, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DSStateType, __pyx_t_4) < 0) __PYX_ERR(14, 18, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/DS.pyx":32
 *     TRUNCATED    = DS_STATE_TRUNCATED
 * 
 * class DSMatType(object):             # <<<<<<<<<<<<<<
 *     """
 *     To refer to one of the matrices stored internally in DS
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__16); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 32, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__16, __pyx_n_s_DSMatType, __pyx_n_s_DSMatType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_To_refer_to_one_of_the_matrices); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 32, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/DS.pyx":49
 *     - `W`:  workspace matrix.
 *     """
 *     A  = DS_MAT_A             # <<<<<<<<<<<<<<
 *     B  = DS_MAT_B
 *     C  = DS_MAT_C
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSMatType(DS_MAT_A); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_A, __pyx_t_4) < 0) __PYX_ERR(14, 49, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":50
 *     """
 *     A  = DS_MAT_A
 *     B  = DS_MAT_B             # <<<<<<<<<<<<<<
 *     C  = DS_MAT_C
 *     T  = DS_MAT_T
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSMatType(DS_MAT_B); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 50, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_B, __pyx_t_4) < 0) __PYX_ERR(14, 50, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":51
 *     A  = DS_MAT_A
 *     B  = DS_MAT_B
 *     C  = DS_MAT_C             # <<<<<<<<<<<<<<
 *     T  = DS_MAT_T
 *     D  = DS_MAT_D
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSMatType(DS_MAT_C); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_C, __pyx_t_4) < 0) __PYX_ERR(14, 51, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":52
 *     B  = DS_MAT_B
 *     C  = DS_MAT_C
 *     T  = DS_MAT_T             # <<<<<<<<<<<<<<
 *     D  = DS_MAT_D
 *     Q  = DS_MAT_Q
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSMatType(DS_MAT_T); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_T, __pyx_t_4) < 0) __PYX_ERR(14, 52, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":53
 *     C  = DS_MAT_C
 *     T  = DS_MAT_T
 *     D  = DS_MAT_D             # <<<<<<<<<<<<<<
 *     Q  = DS_MAT_Q
 *     Z  = DS_MAT_Z
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSMatType(DS_MAT_D); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 53, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_D, __pyx_t_4) < 0) __PYX_ERR(14, 53, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":54
 *     T  = DS_MAT_T
 *     D  = DS_MAT_D
 *     Q  = DS_MAT_Q             # <<<<<<<<<<<<<<
 *     Z  = DS_MAT_Z
 *     X  = DS_MAT_X
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSMatType(DS_MAT_Q); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 54, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_Q, __pyx_t_4) < 0) __PYX_ERR(14, 54, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":55
 *     D  = DS_MAT_D
 *     Q  = DS_MAT_Q
 *     Z  = DS_MAT_Z             # <<<<<<<<<<<<<<
 *     X  = DS_MAT_X
 *     Y  = DS_MAT_Y
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSMatType(DS_MAT_Z); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_Z, __pyx_t_4) < 0) __PYX_ERR(14, 55, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":56
 *     Q  = DS_MAT_Q
 *     Z  = DS_MAT_Z
 *     X  = DS_MAT_X             # <<<<<<<<<<<<<<
 *     Y  = DS_MAT_Y
 *     U  = DS_MAT_U
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSMatType(DS_MAT_X); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 56, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_X, __pyx_t_4) < 0) __PYX_ERR(14, 56, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":57
 *     Z  = DS_MAT_Z
 *     X  = DS_MAT_X
 *     Y  = DS_MAT_Y             # <<<<<<<<<<<<<<
 *     U  = DS_MAT_U
 *     V  = DS_MAT_V
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSMatType(DS_MAT_Y); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 57, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_Y, __pyx_t_4) < 0) __PYX_ERR(14, 57, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":58
 *     X  = DS_MAT_X
 *     Y  = DS_MAT_Y
 *     U  = DS_MAT_U             # <<<<<<<<<<<<<<
 *     V  = DS_MAT_V
 *     W  = DS_MAT_W
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSMatType(DS_MAT_U); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 58, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_U, __pyx_t_4) < 0) __PYX_ERR(14, 58, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":59
 *     Y  = DS_MAT_Y
 *     U  = DS_MAT_U
 *     V  = DS_MAT_V             # <<<<<<<<<<<<<<
 *     W  = DS_MAT_W
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSMatType(DS_MAT_V); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 59, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_V, __pyx_t_4) < 0) __PYX_ERR(14, 59, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":60
 *     U  = DS_MAT_U
 *     V  = DS_MAT_V
 *     W  = DS_MAT_W             # <<<<<<<<<<<<<<
 * 
 * class DSParallelType(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSMatType(DS_MAT_W); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 60, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_W, __pyx_t_4) < 0) __PYX_ERR(14, 60, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":32
 *     TRUNCATED    = DS_STATE_TRUNCATED
 * 
 * class DSMatType(object):             # <<<<<<<<<<<<<<
 *     """
 *     To refer to one of the matrices stored internally in DS
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_DSMatType, __pyx_tuple__16, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 32, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DSMatType, __pyx_t_4) < 0) __PYX_ERR(14, 32, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/DS.pyx":62
 *     W  = DS_MAT_W
 * 
 * class DSParallelType(object):             # <<<<<<<<<<<<<<
 *     """
 *     DS parallel types
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__17); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 62, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__17, __pyx_n_s_DSParallelType, __pyx_n_s_DSParallelType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_DS_parallel_types_REDUNDANT_Eve); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 62, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/DS.pyx":70
 *     - `DISTRIBUTED`:  Used in some cases to distribute the computation among processes.
 *     """
 *     REDUNDANT    = DS_PARALLEL_REDUNDANT             # <<<<<<<<<<<<<<
 *     SYNCHRONIZED = DS_PARALLEL_SYNCHRONIZED
 *     DISTRIBUTED  = DS_PARALLEL_DISTRIBUTED
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSParallelType(DS_PARALLEL_REDUNDANT); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 70, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_REDUNDANT, __pyx_t_4) < 0) __PYX_ERR(14, 70, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":71
 *     """
 *     REDUNDANT    = DS_PARALLEL_REDUNDANT
 *     SYNCHRONIZED = DS_PARALLEL_SYNCHRONIZED             # <<<<<<<<<<<<<<
 *     DISTRIBUTED  = DS_PARALLEL_DISTRIBUTED
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSParallelType(DS_PARALLEL_SYNCHRONIZED); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 71, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SYNCHRONIZED, __pyx_t_4) < 0) __PYX_ERR(14, 71, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":72
 *     REDUNDANT    = DS_PARALLEL_REDUNDANT
 *     SYNCHRONIZED = DS_PARALLEL_SYNCHRONIZED
 *     DISTRIBUTED  = DS_PARALLEL_DISTRIBUTED             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_4 = __Pyx_PyInt_From_DSParallelType(DS_PARALLEL_DISTRIBUTED); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 72, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DISTRIBUTED, __pyx_t_4) < 0) __PYX_ERR(14, 72, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/DS.pyx":62
 *     W  = DS_MAT_W
 * 
 * class DSParallelType(object):             # <<<<<<<<<<<<<<
 *     """
 *     DS parallel types
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_DSParallelType, __pyx_tuple__17, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(14, 62, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DSParallelType, __pyx_t_4) < 0) __PYX_ERR(14, 62, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/DS.pyx":82
 *     """
 * 
 *     Type         = DSType             # <<<<<<<<<<<<<<
 *     StateType    = DSStateType
 *     MatType      = DSMatType
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_DSType); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 82, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_DS->tp_dict, __pyx_n_s_Type, __pyx_t_2) < 0) __PYX_ERR(14, 82, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_DS);

  /* "SLEPc/DS.pyx":83
 * 
 *     Type         = DSType
 *     StateType    = DSStateType             # <<<<<<<<<<<<<<
 *     MatType      = DSMatType
 *     ParallelType = DSParallelType
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_DSStateType); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 83, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_DS->tp_dict, __pyx_n_s_StateType, __pyx_t_2) < 0) __PYX_ERR(14, 83, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_DS);

  /* "SLEPc/DS.pyx":84
 *     Type         = DSType
 *     StateType    = DSStateType
 *     MatType      = DSMatType             # <<<<<<<<<<<<<<
 *     ParallelType = DSParallelType
 * 
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_DSMatType); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 84, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_DS->tp_dict, __pyx_n_s_MatType, __pyx_t_2) < 0) __PYX_ERR(14, 84, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_DS);

  /* "SLEPc/DS.pyx":85
 *     StateType    = DSStateType
 *     MatType      = DSMatType
 *     ParallelType = DSParallelType             # <<<<<<<<<<<<<<
 * 
 *     def __cinit__(self):
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_DSParallelType); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 85, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_DS->tp_dict, __pyx_n_s_ParallelType, __pyx_t_2) < 0) __PYX_ERR(14, 85, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_DS);

  /* "SLEPc/DS.pyx":749
 * # -----------------------------------------------------------------------------
 * 
 * del DSType             # <<<<<<<<<<<<<<
 * del DSStateType
 * del DSMatType
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_DSType) < 0) __PYX_ERR(14, 749, __pyx_L1_error)

  /* "SLEPc/DS.pyx":750
 * 
 * del DSType
 * del DSStateType             # <<<<<<<<<<<<<<
 * del DSMatType
 * del DSParallelType
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_DSStateType) < 0) __PYX_ERR(14, 750, __pyx_L1_error)

  /* "SLEPc/DS.pyx":751
 * del DSType
 * del DSStateType
 * del DSMatType             # <<<<<<<<<<<<<<
 * del DSParallelType
 * 
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_DSMatType) < 0) __PYX_ERR(14, 751, __pyx_L1_error)

  /* "SLEPc/DS.pyx":752
 * del DSStateType
 * del DSMatType
 * del DSParallelType             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_DSParallelType) < 0) __PYX_ERR(14, 752, __pyx_L1_error)

  /* "SLEPc/FN.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class FNType(object):             # <<<<<<<<<<<<<<
 *     """
 *     FN type
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__18); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__18, __pyx_n_s_FNType, __pyx_n_s_FNType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_FN_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/FN.pyx":7
 *     FN type
 *     """
 *     COMBINE  = S_(FNCOMBINE)             # <<<<<<<<<<<<<<
 *     RATIONAL = S_(FNRATIONAL)
 *     EXP      = S_(FNEXP)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(FNCOMBINE); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 7, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_COMBINE, __pyx_t_4) < 0) __PYX_ERR(15, 7, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/FN.pyx":8
 *     """
 *     COMBINE  = S_(FNCOMBINE)
 *     RATIONAL = S_(FNRATIONAL)             # <<<<<<<<<<<<<<
 *     EXP      = S_(FNEXP)
 *     LOG      = S_(FNLOG)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(FNRATIONAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 8, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RATIONAL, __pyx_t_4) < 0) __PYX_ERR(15, 8, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/FN.pyx":9
 *     COMBINE  = S_(FNCOMBINE)
 *     RATIONAL = S_(FNRATIONAL)
 *     EXP      = S_(FNEXP)             # <<<<<<<<<<<<<<
 *     LOG      = S_(FNLOG)
 *     PHI      = S_(FNPHI)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(FNEXP); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_EXP, __pyx_t_4) < 0) __PYX_ERR(15, 9, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/FN.pyx":10
 *     RATIONAL = S_(FNRATIONAL)
 *     EXP      = S_(FNEXP)
 *     LOG      = S_(FNLOG)             # <<<<<<<<<<<<<<
 *     PHI      = S_(FNPHI)
 *     SQRT     = S_(FNSQRT)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(FNLOG); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 10, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LOG, __pyx_t_4) < 0) __PYX_ERR(15, 10, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/FN.pyx":11
 *     EXP      = S_(FNEXP)
 *     LOG      = S_(FNLOG)
 *     PHI      = S_(FNPHI)             # <<<<<<<<<<<<<<
 *     SQRT     = S_(FNSQRT)
 *     INVSQRT  = S_(FNINVSQRT)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(FNPHI); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 11, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_PHI, __pyx_t_4) < 0) __PYX_ERR(15, 11, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/FN.pyx":12
 *     LOG      = S_(FNLOG)
 *     PHI      = S_(FNPHI)
 *     SQRT     = S_(FNSQRT)             # <<<<<<<<<<<<<<
 *     INVSQRT  = S_(FNINVSQRT)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(FNSQRT); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 12, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SQRT, __pyx_t_4) < 0) __PYX_ERR(15, 12, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/FN.pyx":13
 *     PHI      = S_(FNPHI)
 *     SQRT     = S_(FNSQRT)
 *     INVSQRT  = S_(FNINVSQRT)             # <<<<<<<<<<<<<<
 * 
 * class FNCombineType(object):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(FNINVSQRT); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_INVSQRT, __pyx_t_4) < 0) __PYX_ERR(15, 13, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/FN.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class FNType(object):             # <<<<<<<<<<<<<<
 *     """
 *     FN type
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_FNType, __pyx_tuple__18, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_FNType, __pyx_t_4) < 0) __PYX_ERR(15, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/FN.pyx":15
 *     INVSQRT  = S_(FNINVSQRT)
 * 
 * class FNCombineType(object):             # <<<<<<<<<<<<<<
 *     """
 *     FN type of combination of child functions
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__19); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__19, __pyx_n_s_FNCombineType, __pyx_n_s_FNCombineType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_FN_type_of_combination_of_child); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/FN.pyx":24
 *     - `COMPOSE`:   Composition      f(x) = f2(f1(x))
 *     """
 *     ADD      = FN_COMBINE_ADD             # <<<<<<<<<<<<<<
 *     MULTIPLY = FN_COMBINE_MULTIPLY
 *     DIVIDE   = FN_COMBINE_DIVIDE
 */
  __pyx_t_4 = __Pyx_PyInt_From_FNCombineType(FN_COMBINE_ADD); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 24, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ADD, __pyx_t_4) < 0) __PYX_ERR(15, 24, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/FN.pyx":25
 *     """
 *     ADD      = FN_COMBINE_ADD
 *     MULTIPLY = FN_COMBINE_MULTIPLY             # <<<<<<<<<<<<<<
 *     DIVIDE   = FN_COMBINE_DIVIDE
 *     COMPOSE  = FN_COMBINE_COMPOSE
 */
  __pyx_t_4 = __Pyx_PyInt_From_FNCombineType(FN_COMBINE_MULTIPLY); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 25, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_MULTIPLY, __pyx_t_4) < 0) __PYX_ERR(15, 25, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/FN.pyx":26
 *     ADD      = FN_COMBINE_ADD
 *     MULTIPLY = FN_COMBINE_MULTIPLY
 *     DIVIDE   = FN_COMBINE_DIVIDE             # <<<<<<<<<<<<<<
 *     COMPOSE  = FN_COMBINE_COMPOSE
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_FNCombineType(FN_COMBINE_DIVIDE); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 26, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVIDE, __pyx_t_4) < 0) __PYX_ERR(15, 26, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/FN.pyx":27
 *     MULTIPLY = FN_COMBINE_MULTIPLY
 *     DIVIDE   = FN_COMBINE_DIVIDE
 *     COMPOSE  = FN_COMBINE_COMPOSE             # <<<<<<<<<<<<<<
 * 
 * class FNParallelType(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_FNCombineType(FN_COMBINE_COMPOSE); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 27, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_COMPOSE, __pyx_t_4) < 0) __PYX_ERR(15, 27, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/FN.pyx":15
 *     INVSQRT  = S_(FNINVSQRT)
 * 
 * class FNCombineType(object):             # <<<<<<<<<<<<<<
 *     """
 *     FN type of combination of child functions
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_FNCombineType, __pyx_tuple__19, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_FNCombineType, __pyx_t_4) < 0) __PYX_ERR(15, 15, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/FN.pyx":29
 *     COMPOSE  = FN_COMBINE_COMPOSE
 * 
 * class FNParallelType(object):             # <<<<<<<<<<<<<<
 *     """
 *     FN parallel types
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__20); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 29, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__20, __pyx_n_s_FNParallelType, __pyx_n_s_FNParallelType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_FN_parallel_types_REDUNDANT_Eve); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 29, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/FN.pyx":36
 *     - `SYNCHRONIZED`: The first process sends the result to the rest.
 *     """
 *     REDUNDANT    = FN_PARALLEL_REDUNDANT             # <<<<<<<<<<<<<<
 *     SYNCHRONIZED = FN_PARALLEL_SYNCHRONIZED
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_FNParallelType(FN_PARALLEL_REDUNDANT); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 36, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_REDUNDANT, __pyx_t_4) < 0) __PYX_ERR(15, 36, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/FN.pyx":37
 *     """
 *     REDUNDANT    = FN_PARALLEL_REDUNDANT
 *     SYNCHRONIZED = FN_PARALLEL_SYNCHRONIZED             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_4 = __Pyx_PyInt_From_FNParallelType(FN_PARALLEL_SYNCHRONIZED); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 37, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SYNCHRONIZED, __pyx_t_4) < 0) __PYX_ERR(15, 37, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/FN.pyx":29
 *     COMPOSE  = FN_COMBINE_COMPOSE
 * 
 * class FNParallelType(object):             # <<<<<<<<<<<<<<
 *     """
 *     FN parallel types
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_FNParallelType, __pyx_tuple__20, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 29, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_FNParallelType, __pyx_t_4) < 0) __PYX_ERR(15, 29, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/FN.pyx":47
 *     """
 * 
 *     Type         = FNType             # <<<<<<<<<<<<<<
 *     CombineType  = FNCombineType
 *     ParallelType = FNParallelType
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FNType); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 47, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_FN->tp_dict, __pyx_n_s_Type, __pyx_t_2) < 0) __PYX_ERR(15, 47, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_FN);

  /* "SLEPc/FN.pyx":48
 * 
 *     Type         = FNType
 *     CombineType  = FNCombineType             # <<<<<<<<<<<<<<
 *     ParallelType = FNParallelType
 * 
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FNCombineType); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 48, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_FN->tp_dict, __pyx_n_s_CombineType, __pyx_t_2) < 0) __PYX_ERR(15, 48, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_FN);

  /* "SLEPc/FN.pyx":49
 *     Type         = FNType
 *     CombineType  = FNCombineType
 *     ParallelType = FNParallelType             # <<<<<<<<<<<<<<
 * 
 *     def __cinit__(self):
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FNParallelType); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_FN->tp_dict, __pyx_n_s_ParallelType, __pyx_t_2) < 0) __PYX_ERR(15, 49, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_FN);

  /* "SLEPc/FN.pyx":497
 * # -----------------------------------------------------------------------------
 * 
 * del FNType             # <<<<<<<<<<<<<<
 * del FNCombineType
 * del FNParallelType
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_FNType) < 0) __PYX_ERR(15, 497, __pyx_L1_error)

  /* "SLEPc/FN.pyx":498
 * 
 * del FNType
 * del FNCombineType             # <<<<<<<<<<<<<<
 * del FNParallelType
 * 
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_FNCombineType) < 0) __PYX_ERR(15, 498, __pyx_L1_error)

  /* "SLEPc/FN.pyx":499
 * del FNType
 * del FNCombineType
 * del FNParallelType             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_FNParallelType) < 0) __PYX_ERR(15, 499, __pyx_L1_error)

  /* "SLEPc/RG.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class RGType(object):             # <<<<<<<<<<<<<<
 *     """
 *     RG type
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__21); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__21, __pyx_n_s_RGType, __pyx_n_s_RGType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_RG_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/RG.pyx":7
 *     RG type
 *     """
 *     INTERVAL   = S_(RGINTERVAL)             # <<<<<<<<<<<<<<
 *     POLYGON    = S_(RGPOLYGON)
 *     ELLIPSE    = S_(RGELLIPSE)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(RGINTERVAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 7, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_INTERVAL, __pyx_t_4) < 0) __PYX_ERR(16, 7, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/RG.pyx":8
 *     """
 *     INTERVAL   = S_(RGINTERVAL)
 *     POLYGON    = S_(RGPOLYGON)             # <<<<<<<<<<<<<<
 *     ELLIPSE    = S_(RGELLIPSE)
 *     RING       = S_(RGRING)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(RGPOLYGON); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 8, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_POLYGON, __pyx_t_4) < 0) __PYX_ERR(16, 8, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/RG.pyx":9
 *     INTERVAL   = S_(RGINTERVAL)
 *     POLYGON    = S_(RGPOLYGON)
 *     ELLIPSE    = S_(RGELLIPSE)             # <<<<<<<<<<<<<<
 *     RING       = S_(RGRING)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(RGELLIPSE); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ELLIPSE, __pyx_t_4) < 0) __PYX_ERR(16, 9, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/RG.pyx":10
 *     POLYGON    = S_(RGPOLYGON)
 *     ELLIPSE    = S_(RGELLIPSE)
 *     RING       = S_(RGRING)             # <<<<<<<<<<<<<<
 * 
 * class RGQuadRule(object):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(RGRING); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 10, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RING, __pyx_t_4) < 0) __PYX_ERR(16, 10, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/RG.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class RGType(object):             # <<<<<<<<<<<<<<
 *     """
 *     RG type
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_RGType, __pyx_tuple__21, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_RGType, __pyx_t_4) < 0) __PYX_ERR(16, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/RG.pyx":12
 *     RING       = S_(RGRING)
 * 
 * class RGQuadRule(object):             # <<<<<<<<<<<<<<
 *     """
 *     RG quadrature rule for contour integral methods
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__22); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 12, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__22, __pyx_n_s_RGQuadRule, __pyx_n_s_RGQuadRule, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_RG_quadrature_rule_for_contour); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 12, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/RG.pyx":19
 *     - `CHEBYSHEV`:   Chebyshev points.
 *     """
 *     TRAPEZOIDAL = EPS_CISS_QUADRULE_TRAPEZOIDAL             # <<<<<<<<<<<<<<
 *     CHEBYSHEV   = EPS_CISS_QUADRULE_CHEBYSHEV
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSCISSQuadRule(EPS_CISS_QUADRULE_TRAPEZOIDAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 19, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TRAPEZOIDAL, __pyx_t_4) < 0) __PYX_ERR(16, 19, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/RG.pyx":20
 *     """
 *     TRAPEZOIDAL = EPS_CISS_QUADRULE_TRAPEZOIDAL
 *     CHEBYSHEV   = EPS_CISS_QUADRULE_CHEBYSHEV             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSCISSQuadRule(EPS_CISS_QUADRULE_CHEBYSHEV); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 20, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CHEBYSHEV, __pyx_t_4) < 0) __PYX_ERR(16, 20, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/RG.pyx":12
 *     RING       = S_(RGRING)
 * 
 * class RGQuadRule(object):             # <<<<<<<<<<<<<<
 *     """
 *     RG quadrature rule for contour integral methods
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_RGQuadRule, __pyx_tuple__22, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 12, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_RGQuadRule, __pyx_t_4) < 0) __PYX_ERR(16, 12, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/RG.pyx":30
 *     """
 * 
 *     Type     = RGType             # <<<<<<<<<<<<<<
 *     QuadRule = RGQuadRule
 * 
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_RGType); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 30, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_RG->tp_dict, __pyx_n_s_Type, __pyx_t_2) < 0) __PYX_ERR(16, 30, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_RG);

  /* "SLEPc/RG.pyx":31
 * 
 *     Type     = RGType
 *     QuadRule = RGQuadRule             # <<<<<<<<<<<<<<
 * 
 *     def __cinit__(self):
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_RGQuadRule); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 31, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_RG->tp_dict, __pyx_n_s_QuadRule, __pyx_t_2) < 0) __PYX_ERR(16, 31, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_RG);

  /* "SLEPc/RG.pyx":559
 * # -----------------------------------------------------------------------------
 * 
 * del RGType             # <<<<<<<<<<<<<<
 * del RGQuadRule
 * 
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_RGType) < 0) __PYX_ERR(16, 559, __pyx_L1_error)

  /* "SLEPc/RG.pyx":560
 * 
 * del RGType
 * del RGQuadRule             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_RGQuadRule) < 0) __PYX_ERR(16, 560, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class EPSType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS type
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__23); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__23, __pyx_n_s_EPSType, __pyx_n_s_EPSType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_EPS_type_Native_sparse_eigensol); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/EPS.pyx":36
 *     """
 *     # provided implementations
 *     POWER        = S_(EPSPOWER)             # <<<<<<<<<<<<<<
 *     SUBSPACE     = S_(EPSSUBSPACE)
 *     ARNOLDI      = S_(EPSARNOLDI)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSPOWER); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 36, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_POWER, __pyx_t_4) < 0) __PYX_ERR(17, 36, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":37
 *     # provided implementations
 *     POWER        = S_(EPSPOWER)
 *     SUBSPACE     = S_(EPSSUBSPACE)             # <<<<<<<<<<<<<<
 *     ARNOLDI      = S_(EPSARNOLDI)
 *     LANCZOS      = S_(EPSLANCZOS)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSSUBSPACE); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 37, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SUBSPACE, __pyx_t_4) < 0) __PYX_ERR(17, 37, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":38
 *     POWER        = S_(EPSPOWER)
 *     SUBSPACE     = S_(EPSSUBSPACE)
 *     ARNOLDI      = S_(EPSARNOLDI)             # <<<<<<<<<<<<<<
 *     LANCZOS      = S_(EPSLANCZOS)
 *     KRYLOVSCHUR  = S_(EPSKRYLOVSCHUR)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSARNOLDI); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 38, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ARNOLDI, __pyx_t_4) < 0) __PYX_ERR(17, 38, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":39
 *     SUBSPACE     = S_(EPSSUBSPACE)
 *     ARNOLDI      = S_(EPSARNOLDI)
 *     LANCZOS      = S_(EPSLANCZOS)             # <<<<<<<<<<<<<<
 *     KRYLOVSCHUR  = S_(EPSKRYLOVSCHUR)
 *     GD           = S_(EPSGD)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSLANCZOS); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 39, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LANCZOS, __pyx_t_4) < 0) __PYX_ERR(17, 39, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":40
 *     ARNOLDI      = S_(EPSARNOLDI)
 *     LANCZOS      = S_(EPSLANCZOS)
 *     KRYLOVSCHUR  = S_(EPSKRYLOVSCHUR)             # <<<<<<<<<<<<<<
 *     GD           = S_(EPSGD)
 *     JD           = S_(EPSJD)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSKRYLOVSCHUR); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 40, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_KRYLOVSCHUR, __pyx_t_4) < 0) __PYX_ERR(17, 40, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":41
 *     LANCZOS      = S_(EPSLANCZOS)
 *     KRYLOVSCHUR  = S_(EPSKRYLOVSCHUR)
 *     GD           = S_(EPSGD)             # <<<<<<<<<<<<<<
 *     JD           = S_(EPSJD)
 *     RQCG         = S_(EPSRQCG)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSGD); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 41, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_GD, __pyx_t_4) < 0) __PYX_ERR(17, 41, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":42
 *     KRYLOVSCHUR  = S_(EPSKRYLOVSCHUR)
 *     GD           = S_(EPSGD)
 *     JD           = S_(EPSJD)             # <<<<<<<<<<<<<<
 *     RQCG         = S_(EPSRQCG)
 *     LOBPCG       = S_(EPSLOBPCG)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSJD); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 42, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_JD, __pyx_t_4) < 0) __PYX_ERR(17, 42, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":43
 *     GD           = S_(EPSGD)
 *     JD           = S_(EPSJD)
 *     RQCG         = S_(EPSRQCG)             # <<<<<<<<<<<<<<
 *     LOBPCG       = S_(EPSLOBPCG)
 *     CISS         = S_(EPSCISS)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSRQCG); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 43, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RQCG, __pyx_t_4) < 0) __PYX_ERR(17, 43, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":44
 *     JD           = S_(EPSJD)
 *     RQCG         = S_(EPSRQCG)
 *     LOBPCG       = S_(EPSLOBPCG)             # <<<<<<<<<<<<<<
 *     CISS         = S_(EPSCISS)
 *     LYAPII       = S_(EPSLYAPII)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSLOBPCG); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 44, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LOBPCG, __pyx_t_4) < 0) __PYX_ERR(17, 44, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":45
 *     RQCG         = S_(EPSRQCG)
 *     LOBPCG       = S_(EPSLOBPCG)
 *     CISS         = S_(EPSCISS)             # <<<<<<<<<<<<<<
 *     LYAPII       = S_(EPSLYAPII)
 *     LAPACK       = S_(EPSLAPACK)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSCISS); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 45, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CISS, __pyx_t_4) < 0) __PYX_ERR(17, 45, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":46
 *     LOBPCG       = S_(EPSLOBPCG)
 *     CISS         = S_(EPSCISS)
 *     LYAPII       = S_(EPSLYAPII)             # <<<<<<<<<<<<<<
 *     LAPACK       = S_(EPSLAPACK)
 *     # with external libraries
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSLYAPII); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 46, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LYAPII, __pyx_t_4) < 0) __PYX_ERR(17, 46, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":47
 *     CISS         = S_(EPSCISS)
 *     LYAPII       = S_(EPSLYAPII)
 *     LAPACK       = S_(EPSLAPACK)             # <<<<<<<<<<<<<<
 *     # with external libraries
 *     ARPACK       = S_(EPSARPACK)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSLAPACK); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 47, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LAPACK, __pyx_t_4) < 0) __PYX_ERR(17, 47, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":49
 *     LAPACK       = S_(EPSLAPACK)
 *     # with external libraries
 *     ARPACK       = S_(EPSARPACK)             # <<<<<<<<<<<<<<
 *     TRLAN        = S_(EPSTRLAN)
 *     BLOPEX       = S_(EPSBLOPEX)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSARPACK); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ARPACK, __pyx_t_4) < 0) __PYX_ERR(17, 49, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":50
 *     # with external libraries
 *     ARPACK       = S_(EPSARPACK)
 *     TRLAN        = S_(EPSTRLAN)             # <<<<<<<<<<<<<<
 *     BLOPEX       = S_(EPSBLOPEX)
 *     PRIMME       = S_(EPSPRIMME)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSTRLAN); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 50, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TRLAN, __pyx_t_4) < 0) __PYX_ERR(17, 50, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":51
 *     ARPACK       = S_(EPSARPACK)
 *     TRLAN        = S_(EPSTRLAN)
 *     BLOPEX       = S_(EPSBLOPEX)             # <<<<<<<<<<<<<<
 *     PRIMME       = S_(EPSPRIMME)
 *     FEAST        = S_(EPSFEAST)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSBLOPEX); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_BLOPEX, __pyx_t_4) < 0) __PYX_ERR(17, 51, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":52
 *     TRLAN        = S_(EPSTRLAN)
 *     BLOPEX       = S_(EPSBLOPEX)
 *     PRIMME       = S_(EPSPRIMME)             # <<<<<<<<<<<<<<
 *     FEAST        = S_(EPSFEAST)
 *     SCALAPACK    = S_(EPSSCALAPACK)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSPRIMME); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_PRIMME, __pyx_t_4) < 0) __PYX_ERR(17, 52, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":53
 *     BLOPEX       = S_(EPSBLOPEX)
 *     PRIMME       = S_(EPSPRIMME)
 *     FEAST        = S_(EPSFEAST)             # <<<<<<<<<<<<<<
 *     SCALAPACK    = S_(EPSSCALAPACK)
 *     ELPA         = S_(EPSELPA)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSFEAST); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 53, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_FEAST, __pyx_t_4) < 0) __PYX_ERR(17, 53, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":54
 *     PRIMME       = S_(EPSPRIMME)
 *     FEAST        = S_(EPSFEAST)
 *     SCALAPACK    = S_(EPSSCALAPACK)             # <<<<<<<<<<<<<<
 *     ELPA         = S_(EPSELPA)
 *     ELEMENTAL    = S_(EPSELEMENTAL)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSSCALAPACK); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 54, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SCALAPACK, __pyx_t_4) < 0) __PYX_ERR(17, 54, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":55
 *     FEAST        = S_(EPSFEAST)
 *     SCALAPACK    = S_(EPSSCALAPACK)
 *     ELPA         = S_(EPSELPA)             # <<<<<<<<<<<<<<
 *     ELEMENTAL    = S_(EPSELEMENTAL)
 *     EVSL         = S_(EPSEVSL)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSELPA); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ELPA, __pyx_t_4) < 0) __PYX_ERR(17, 55, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":56
 *     SCALAPACK    = S_(EPSSCALAPACK)
 *     ELPA         = S_(EPSELPA)
 *     ELEMENTAL    = S_(EPSELEMENTAL)             # <<<<<<<<<<<<<<
 *     EVSL         = S_(EPSEVSL)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSELEMENTAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 56, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ELEMENTAL, __pyx_t_4) < 0) __PYX_ERR(17, 56, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":57
 *     ELPA         = S_(EPSELPA)
 *     ELEMENTAL    = S_(EPSELEMENTAL)
 *     EVSL         = S_(EPSEVSL)             # <<<<<<<<<<<<<<
 * 
 * class EPSProblemType(object):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(EPSEVSL); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 57, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_EVSL, __pyx_t_4) < 0) __PYX_ERR(17, 57, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class EPSType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS type
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EPSType, __pyx_tuple__23, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSType, __pyx_t_4) < 0) __PYX_ERR(17, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/EPS.pyx":59
 *     EVSL         = S_(EPSEVSL)
 * 
 * class EPSProblemType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS problem type
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__24); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 59, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__24, __pyx_n_s_EPSProblemType, __pyx_n_s_EPSProblemType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_EPS_problem_type_HEP_Hermitian); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 59, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/EPS.pyx":71
 *     - `GHIEP`:  Generalized Hermitian-indefinite eigenproblem.
 *     """
 *     HEP    = EPS_HEP             # <<<<<<<<<<<<<<
 *     NHEP   = EPS_NHEP
 *     GHEP   = EPS_GHEP
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSProblemType(EPS_HEP); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 71, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_HEP, __pyx_t_4) < 0) __PYX_ERR(17, 71, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":72
 *     """
 *     HEP    = EPS_HEP
 *     NHEP   = EPS_NHEP             # <<<<<<<<<<<<<<
 *     GHEP   = EPS_GHEP
 *     GNHEP  = EPS_GNHEP
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSProblemType(EPS_NHEP); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 72, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NHEP, __pyx_t_4) < 0) __PYX_ERR(17, 72, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":73
 *     HEP    = EPS_HEP
 *     NHEP   = EPS_NHEP
 *     GHEP   = EPS_GHEP             # <<<<<<<<<<<<<<
 *     GNHEP  = EPS_GNHEP
 *     PGNHEP = EPS_PGNHEP
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSProblemType(EPS_GHEP); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_GHEP, __pyx_t_4) < 0) __PYX_ERR(17, 73, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":74
 *     NHEP   = EPS_NHEP
 *     GHEP   = EPS_GHEP
 *     GNHEP  = EPS_GNHEP             # <<<<<<<<<<<<<<
 *     PGNHEP = EPS_PGNHEP
 *     GHIEP  = EPS_GHIEP
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSProblemType(EPS_GNHEP); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 74, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_GNHEP, __pyx_t_4) < 0) __PYX_ERR(17, 74, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":75
 *     GHEP   = EPS_GHEP
 *     GNHEP  = EPS_GNHEP
 *     PGNHEP = EPS_PGNHEP             # <<<<<<<<<<<<<<
 *     GHIEP  = EPS_GHIEP
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSProblemType(EPS_PGNHEP); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 75, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_PGNHEP, __pyx_t_4) < 0) __PYX_ERR(17, 75, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":76
 *     GNHEP  = EPS_GNHEP
 *     PGNHEP = EPS_PGNHEP
 *     GHIEP  = EPS_GHIEP             # <<<<<<<<<<<<<<
 * 
 * class EPSExtraction(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSProblemType(EPS_GHIEP); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 76, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_GHIEP, __pyx_t_4) < 0) __PYX_ERR(17, 76, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":59
 *     EVSL         = S_(EPSEVSL)
 * 
 * class EPSProblemType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS problem type
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EPSProblemType, __pyx_tuple__24, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 59, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSProblemType, __pyx_t_4) < 0) __PYX_ERR(17, 59, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/EPS.pyx":78
 *     GHIEP  = EPS_GHIEP
 * 
 * class EPSExtraction(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS extraction technique
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__25); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 78, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__25, __pyx_n_s_EPSExtraction, __pyx_n_s_EPSExtraction, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_EPS_extraction_technique_RITZ_S); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 78, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/EPS.pyx":90
 *     - `REFINED_HARMONIC`:  Refined harmonic extraction.
 *     """
 *     RITZ              = EPS_RITZ             # <<<<<<<<<<<<<<
 *     HARMONIC          = EPS_HARMONIC
 *     HARMONIC_RELATIVE = EPS_HARMONIC_RELATIVE
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSExtraction(EPS_RITZ); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 90, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RITZ, __pyx_t_4) < 0) __PYX_ERR(17, 90, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":91
 *     """
 *     RITZ              = EPS_RITZ
 *     HARMONIC          = EPS_HARMONIC             # <<<<<<<<<<<<<<
 *     HARMONIC_RELATIVE = EPS_HARMONIC_RELATIVE
 *     HARMONIC_RIGHT    = EPS_HARMONIC_RIGHT
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSExtraction(EPS_HARMONIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 91, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_HARMONIC, __pyx_t_4) < 0) __PYX_ERR(17, 91, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":92
 *     RITZ              = EPS_RITZ
 *     HARMONIC          = EPS_HARMONIC
 *     HARMONIC_RELATIVE = EPS_HARMONIC_RELATIVE             # <<<<<<<<<<<<<<
 *     HARMONIC_RIGHT    = EPS_HARMONIC_RIGHT
 *     HARMONIC_LARGEST  = EPS_HARMONIC_LARGEST
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSExtraction(EPS_HARMONIC_RELATIVE); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 92, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_HARMONIC_RELATIVE, __pyx_t_4) < 0) __PYX_ERR(17, 92, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":93
 *     HARMONIC          = EPS_HARMONIC
 *     HARMONIC_RELATIVE = EPS_HARMONIC_RELATIVE
 *     HARMONIC_RIGHT    = EPS_HARMONIC_RIGHT             # <<<<<<<<<<<<<<
 *     HARMONIC_LARGEST  = EPS_HARMONIC_LARGEST
 *     REFINED           = EPS_REFINED
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSExtraction(EPS_HARMONIC_RIGHT); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 93, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_HARMONIC_RIGHT, __pyx_t_4) < 0) __PYX_ERR(17, 93, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":94
 *     HARMONIC_RELATIVE = EPS_HARMONIC_RELATIVE
 *     HARMONIC_RIGHT    = EPS_HARMONIC_RIGHT
 *     HARMONIC_LARGEST  = EPS_HARMONIC_LARGEST             # <<<<<<<<<<<<<<
 *     REFINED           = EPS_REFINED
 *     REFINED_HARMONIC  = EPS_REFINED_HARMONIC
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSExtraction(EPS_HARMONIC_LARGEST); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 94, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_HARMONIC_LARGEST, __pyx_t_4) < 0) __PYX_ERR(17, 94, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":95
 *     HARMONIC_RIGHT    = EPS_HARMONIC_RIGHT
 *     HARMONIC_LARGEST  = EPS_HARMONIC_LARGEST
 *     REFINED           = EPS_REFINED             # <<<<<<<<<<<<<<
 *     REFINED_HARMONIC  = EPS_REFINED_HARMONIC
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSExtraction(EPS_REFINED); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 95, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_REFINED, __pyx_t_4) < 0) __PYX_ERR(17, 95, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":96
 *     HARMONIC_LARGEST  = EPS_HARMONIC_LARGEST
 *     REFINED           = EPS_REFINED
 *     REFINED_HARMONIC  = EPS_REFINED_HARMONIC             # <<<<<<<<<<<<<<
 * 
 * class EPSBalance(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSExtraction(EPS_REFINED_HARMONIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 96, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_REFINED_HARMONIC, __pyx_t_4) < 0) __PYX_ERR(17, 96, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":78
 *     GHIEP  = EPS_GHIEP
 * 
 * class EPSExtraction(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS extraction technique
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EPSExtraction, __pyx_tuple__25, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 78, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSExtraction, __pyx_t_4) < 0) __PYX_ERR(17, 78, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/EPS.pyx":98
 *     REFINED_HARMONIC  = EPS_REFINED_HARMONIC
 * 
 * class EPSBalance(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS type of balancing used for non-Hermitian problems
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__26); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 98, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__26, __pyx_n_s_EPSBalance, __pyx_n_s_EPSBalance, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_EPS_type_of_balancing_used_for); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 98, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/EPS.pyx":107
 *     - `USER`:     User-provided balancing matrices.
 *     """
 *     NONE    = EPS_BALANCE_NONE             # <<<<<<<<<<<<<<
 *     ONESIDE = EPS_BALANCE_ONESIDE
 *     TWOSIDE = EPS_BALANCE_TWOSIDE
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSBalance(EPS_BALANCE_NONE); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NONE, __pyx_t_4) < 0) __PYX_ERR(17, 107, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":108
 *     """
 *     NONE    = EPS_BALANCE_NONE
 *     ONESIDE = EPS_BALANCE_ONESIDE             # <<<<<<<<<<<<<<
 *     TWOSIDE = EPS_BALANCE_TWOSIDE
 *     USER    = EPS_BALANCE_USER
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSBalance(EPS_BALANCE_ONESIDE); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 108, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ONESIDE, __pyx_t_4) < 0) __PYX_ERR(17, 108, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":109
 *     NONE    = EPS_BALANCE_NONE
 *     ONESIDE = EPS_BALANCE_ONESIDE
 *     TWOSIDE = EPS_BALANCE_TWOSIDE             # <<<<<<<<<<<<<<
 *     USER    = EPS_BALANCE_USER
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSBalance(EPS_BALANCE_TWOSIDE); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 109, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TWOSIDE, __pyx_t_4) < 0) __PYX_ERR(17, 109, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":110
 *     ONESIDE = EPS_BALANCE_ONESIDE
 *     TWOSIDE = EPS_BALANCE_TWOSIDE
 *     USER    = EPS_BALANCE_USER             # <<<<<<<<<<<<<<
 * 
 * class EPSErrorType(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSBalance(EPS_BALANCE_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 110, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_USER, __pyx_t_4) < 0) __PYX_ERR(17, 110, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":98
 *     REFINED_HARMONIC  = EPS_REFINED_HARMONIC
 * 
 * class EPSBalance(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS type of balancing used for non-Hermitian problems
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EPSBalance, __pyx_tuple__26, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 98, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSBalance, __pyx_t_4) < 0) __PYX_ERR(17, 98, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/EPS.pyx":112
 *     USER    = EPS_BALANCE_USER
 * 
 * class EPSErrorType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS error type to assess accuracy of computed solutions
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__27); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 112, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__27, __pyx_n_s_EPSErrorType, __pyx_n_s_EPSErrorType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_EPS_error_type_to_assess_accura); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 112, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/EPS.pyx":120
 *     - `BACKWARD`: Backward error.
 *     """
 *     ABSOLUTE = EPS_ERROR_ABSOLUTE             # <<<<<<<<<<<<<<
 *     RELATIVE = EPS_ERROR_RELATIVE
 *     BACKWARD = EPS_ERROR_BACKWARD
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSErrorType(EPS_ERROR_ABSOLUTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 120, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ABSOLUTE, __pyx_t_4) < 0) __PYX_ERR(17, 120, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":121
 *     """
 *     ABSOLUTE = EPS_ERROR_ABSOLUTE
 *     RELATIVE = EPS_ERROR_RELATIVE             # <<<<<<<<<<<<<<
 *     BACKWARD = EPS_ERROR_BACKWARD
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSErrorType(EPS_ERROR_RELATIVE); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 121, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RELATIVE, __pyx_t_4) < 0) __PYX_ERR(17, 121, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":122
 *     ABSOLUTE = EPS_ERROR_ABSOLUTE
 *     RELATIVE = EPS_ERROR_RELATIVE
 *     BACKWARD = EPS_ERROR_BACKWARD             # <<<<<<<<<<<<<<
 * 
 * class EPSWhich(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSErrorType(EPS_ERROR_BACKWARD); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 122, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_BACKWARD, __pyx_t_4) < 0) __PYX_ERR(17, 122, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":112
 *     USER    = EPS_BALANCE_USER
 * 
 * class EPSErrorType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS error type to assess accuracy of computed solutions
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EPSErrorType, __pyx_tuple__27, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 112, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSErrorType, __pyx_t_4) < 0) __PYX_ERR(17, 112, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/EPS.pyx":124
 *     BACKWARD = EPS_ERROR_BACKWARD
 * 
 * class EPSWhich(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS desired part of spectrum
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__28); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 124, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__28, __pyx_n_s_EPSWhich, __pyx_n_s_EPSWhich, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_EPS_desired_part_of_spectrum_LA); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 124, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/EPS.pyx":140
 *     - `USER`:               User defined selection.
 *     """
 *     LARGEST_MAGNITUDE  = EPS_LARGEST_MAGNITUDE             # <<<<<<<<<<<<<<
 *     SMALLEST_MAGNITUDE = EPS_SMALLEST_MAGNITUDE
 *     LARGEST_REAL       = EPS_LARGEST_REAL
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSWhich(EPS_LARGEST_MAGNITUDE); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 140, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LARGEST_MAGNITUDE, __pyx_t_4) < 0) __PYX_ERR(17, 140, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":141
 *     """
 *     LARGEST_MAGNITUDE  = EPS_LARGEST_MAGNITUDE
 *     SMALLEST_MAGNITUDE = EPS_SMALLEST_MAGNITUDE             # <<<<<<<<<<<<<<
 *     LARGEST_REAL       = EPS_LARGEST_REAL
 *     SMALLEST_REAL      = EPS_SMALLEST_REAL
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSWhich(EPS_SMALLEST_MAGNITUDE); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 141, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SMALLEST_MAGNITUDE, __pyx_t_4) < 0) __PYX_ERR(17, 141, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":142
 *     LARGEST_MAGNITUDE  = EPS_LARGEST_MAGNITUDE
 *     SMALLEST_MAGNITUDE = EPS_SMALLEST_MAGNITUDE
 *     LARGEST_REAL       = EPS_LARGEST_REAL             # <<<<<<<<<<<<<<
 *     SMALLEST_REAL      = EPS_SMALLEST_REAL
 *     LARGEST_IMAGINARY  = EPS_LARGEST_IMAGINARY
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSWhich(EPS_LARGEST_REAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LARGEST_REAL, __pyx_t_4) < 0) __PYX_ERR(17, 142, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":143
 *     SMALLEST_MAGNITUDE = EPS_SMALLEST_MAGNITUDE
 *     LARGEST_REAL       = EPS_LARGEST_REAL
 *     SMALLEST_REAL      = EPS_SMALLEST_REAL             # <<<<<<<<<<<<<<
 *     LARGEST_IMAGINARY  = EPS_LARGEST_IMAGINARY
 *     SMALLEST_IMAGINARY = EPS_SMALLEST_IMAGINARY
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSWhich(EPS_SMALLEST_REAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 143, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SMALLEST_REAL, __pyx_t_4) < 0) __PYX_ERR(17, 143, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":144
 *     LARGEST_REAL       = EPS_LARGEST_REAL
 *     SMALLEST_REAL      = EPS_SMALLEST_REAL
 *     LARGEST_IMAGINARY  = EPS_LARGEST_IMAGINARY             # <<<<<<<<<<<<<<
 *     SMALLEST_IMAGINARY = EPS_SMALLEST_IMAGINARY
 *     TARGET_MAGNITUDE   = EPS_TARGET_MAGNITUDE
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSWhich(EPS_LARGEST_IMAGINARY); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 144, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LARGEST_IMAGINARY, __pyx_t_4) < 0) __PYX_ERR(17, 144, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":145
 *     SMALLEST_REAL      = EPS_SMALLEST_REAL
 *     LARGEST_IMAGINARY  = EPS_LARGEST_IMAGINARY
 *     SMALLEST_IMAGINARY = EPS_SMALLEST_IMAGINARY             # <<<<<<<<<<<<<<
 *     TARGET_MAGNITUDE   = EPS_TARGET_MAGNITUDE
 *     TARGET_REAL        = EPS_TARGET_REAL
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSWhich(EPS_SMALLEST_IMAGINARY); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 145, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SMALLEST_IMAGINARY, __pyx_t_4) < 0) __PYX_ERR(17, 145, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":146
 *     LARGEST_IMAGINARY  = EPS_LARGEST_IMAGINARY
 *     SMALLEST_IMAGINARY = EPS_SMALLEST_IMAGINARY
 *     TARGET_MAGNITUDE   = EPS_TARGET_MAGNITUDE             # <<<<<<<<<<<<<<
 *     TARGET_REAL        = EPS_TARGET_REAL
 *     TARGET_IMAGINARY   = EPS_TARGET_IMAGINARY
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSWhich(EPS_TARGET_MAGNITUDE); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 146, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TARGET_MAGNITUDE, __pyx_t_4) < 0) __PYX_ERR(17, 146, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":147
 *     SMALLEST_IMAGINARY = EPS_SMALLEST_IMAGINARY
 *     TARGET_MAGNITUDE   = EPS_TARGET_MAGNITUDE
 *     TARGET_REAL        = EPS_TARGET_REAL             # <<<<<<<<<<<<<<
 *     TARGET_IMAGINARY   = EPS_TARGET_IMAGINARY
 *     ALL                = EPS_ALL
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSWhich(EPS_TARGET_REAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 147, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TARGET_REAL, __pyx_t_4) < 0) __PYX_ERR(17, 147, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":148
 *     TARGET_MAGNITUDE   = EPS_TARGET_MAGNITUDE
 *     TARGET_REAL        = EPS_TARGET_REAL
 *     TARGET_IMAGINARY   = EPS_TARGET_IMAGINARY             # <<<<<<<<<<<<<<
 *     ALL                = EPS_ALL
 *     USER               = EPS_WHICH_USER
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSWhich(EPS_TARGET_IMAGINARY); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 148, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TARGET_IMAGINARY, __pyx_t_4) < 0) __PYX_ERR(17, 148, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":149
 *     TARGET_REAL        = EPS_TARGET_REAL
 *     TARGET_IMAGINARY   = EPS_TARGET_IMAGINARY
 *     ALL                = EPS_ALL             # <<<<<<<<<<<<<<
 *     USER               = EPS_WHICH_USER
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSWhich(EPS_ALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 149, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ALL, __pyx_t_4) < 0) __PYX_ERR(17, 149, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":150
 *     TARGET_IMAGINARY   = EPS_TARGET_IMAGINARY
 *     ALL                = EPS_ALL
 *     USER               = EPS_WHICH_USER             # <<<<<<<<<<<<<<
 * 
 * class EPSConv(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSWhich(EPS_WHICH_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 150, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_USER, __pyx_t_4) < 0) __PYX_ERR(17, 150, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":124
 *     BACKWARD = EPS_ERROR_BACKWARD
 * 
 * class EPSWhich(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS desired part of spectrum
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EPSWhich, __pyx_tuple__28, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 124, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSWhich, __pyx_t_4) < 0) __PYX_ERR(17, 124, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/EPS.pyx":152
 *     USER               = EPS_WHICH_USER
 * 
 * class EPSConv(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS convergence test
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__29); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 152, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__29, __pyx_n_s_EPSConv, __pyx_n_s_EPSConv, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_EPS_convergence_test_ABS_Absolu); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 152, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/EPS.pyx":161
 *     - `USER`: User-defined convergence test.
 *     """
 *     ABS  = EPS_CONV_ABS             # <<<<<<<<<<<<<<
 *     REL  = EPS_CONV_REL
 *     NORM = EPS_CONV_NORM
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSConv(EPS_CONV_ABS); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 161, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ABS, __pyx_t_4) < 0) __PYX_ERR(17, 161, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":162
 *     """
 *     ABS  = EPS_CONV_ABS
 *     REL  = EPS_CONV_REL             # <<<<<<<<<<<<<<
 *     NORM = EPS_CONV_NORM
 *     USER = EPS_CONV_USER
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSConv(EPS_CONV_REL); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 162, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_REL, __pyx_t_4) < 0) __PYX_ERR(17, 162, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":163
 *     ABS  = EPS_CONV_ABS
 *     REL  = EPS_CONV_REL
 *     NORM = EPS_CONV_NORM             # <<<<<<<<<<<<<<
 *     USER = EPS_CONV_USER
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSConv(EPS_CONV_NORM); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 163, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NORM, __pyx_t_4) < 0) __PYX_ERR(17, 163, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":164
 *     REL  = EPS_CONV_REL
 *     NORM = EPS_CONV_NORM
 *     USER = EPS_CONV_USER             # <<<<<<<<<<<<<<
 * 
 * class EPSStop(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSConv(EPS_CONV_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 164, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_USER, __pyx_t_4) < 0) __PYX_ERR(17, 164, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":152
 *     USER               = EPS_WHICH_USER
 * 
 * class EPSConv(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS convergence test
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EPSConv, __pyx_tuple__29, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 152, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSConv, __pyx_t_4) < 0) __PYX_ERR(17, 152, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/EPS.pyx":166
 *     USER = EPS_CONV_USER
 * 
 * class EPSStop(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS stopping test
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__30); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 166, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__30, __pyx_n_s_EPSStop, __pyx_n_s_EPSStop, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_EPS_stopping_test_BASIC_Default); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 166, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/EPS.pyx":173
 *     - `USER`:  User-defined stopping test.
 *     """
 *     BASIC = EPS_STOP_BASIC             # <<<<<<<<<<<<<<
 *     USER  = EPS_STOP_USER
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSStop(EPS_STOP_BASIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 173, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_BASIC, __pyx_t_4) < 0) __PYX_ERR(17, 173, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":174
 *     """
 *     BASIC = EPS_STOP_BASIC
 *     USER  = EPS_STOP_USER             # <<<<<<<<<<<<<<
 * 
 * class EPSConvergedReason(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSStop(EPS_STOP_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 174, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_USER, __pyx_t_4) < 0) __PYX_ERR(17, 174, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":166
 *     USER = EPS_CONV_USER
 * 
 * class EPSStop(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS stopping test
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EPSStop, __pyx_tuple__30, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 166, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSStop, __pyx_t_4) < 0) __PYX_ERR(17, 166, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/EPS.pyx":176
 *     USER  = EPS_STOP_USER
 * 
 * class EPSConvergedReason(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS convergence reasons
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__31); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 176, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__31, __pyx_n_s_EPSConvergedReason, __pyx_n_s_EPSConvergedReason, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_EPS_convergence_reasons_CONVERG); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 176, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/EPS.pyx":187
 *     - `CONVERGED_ITERATING`:    Iteration not finished yet.
 *     """
 *     CONVERGED_TOL          = EPS_CONVERGED_TOL             # <<<<<<<<<<<<<<
 *     CONVERGED_USER         = EPS_CONVERGED_USER
 *     DIVERGED_ITS           = EPS_DIVERGED_ITS
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSConvergedReason(EPS_CONVERGED_TOL); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 187, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_TOL, __pyx_t_4) < 0) __PYX_ERR(17, 187, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":188
 *     """
 *     CONVERGED_TOL          = EPS_CONVERGED_TOL
 *     CONVERGED_USER         = EPS_CONVERGED_USER             # <<<<<<<<<<<<<<
 *     DIVERGED_ITS           = EPS_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN     = EPS_DIVERGED_BREAKDOWN
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSConvergedReason(EPS_CONVERGED_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 188, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_USER, __pyx_t_4) < 0) __PYX_ERR(17, 188, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":189
 *     CONVERGED_TOL          = EPS_CONVERGED_TOL
 *     CONVERGED_USER         = EPS_CONVERGED_USER
 *     DIVERGED_ITS           = EPS_DIVERGED_ITS             # <<<<<<<<<<<<<<
 *     DIVERGED_BREAKDOWN     = EPS_DIVERGED_BREAKDOWN
 *     DIVERGED_SYMMETRY_LOST = EPS_DIVERGED_SYMMETRY_LOST
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSConvergedReason(EPS_DIVERGED_ITS); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 189, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVERGED_ITS, __pyx_t_4) < 0) __PYX_ERR(17, 189, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":190
 *     CONVERGED_USER         = EPS_CONVERGED_USER
 *     DIVERGED_ITS           = EPS_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN     = EPS_DIVERGED_BREAKDOWN             # <<<<<<<<<<<<<<
 *     DIVERGED_SYMMETRY_LOST = EPS_DIVERGED_SYMMETRY_LOST
 *     CONVERGED_ITERATING    = EPS_CONVERGED_ITERATING
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSConvergedReason(EPS_DIVERGED_BREAKDOWN); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 190, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVERGED_BREAKDOWN, __pyx_t_4) < 0) __PYX_ERR(17, 190, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":191
 *     DIVERGED_ITS           = EPS_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN     = EPS_DIVERGED_BREAKDOWN
 *     DIVERGED_SYMMETRY_LOST = EPS_DIVERGED_SYMMETRY_LOST             # <<<<<<<<<<<<<<
 *     CONVERGED_ITERATING    = EPS_CONVERGED_ITERATING
 *     ITERATING              = EPS_CONVERGED_ITERATING
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSConvergedReason(EPS_DIVERGED_SYMMETRY_LOST); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVERGED_SYMMETRY_LOST, __pyx_t_4) < 0) __PYX_ERR(17, 191, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":192
 *     DIVERGED_BREAKDOWN     = EPS_DIVERGED_BREAKDOWN
 *     DIVERGED_SYMMETRY_LOST = EPS_DIVERGED_SYMMETRY_LOST
 *     CONVERGED_ITERATING    = EPS_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *     ITERATING              = EPS_CONVERGED_ITERATING
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSConvergedReason(EPS_CONVERGED_ITERATING); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 192, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_ITERATING, __pyx_t_4) < 0) __PYX_ERR(17, 192, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":193
 *     DIVERGED_SYMMETRY_LOST = EPS_DIVERGED_SYMMETRY_LOST
 *     CONVERGED_ITERATING    = EPS_CONVERGED_ITERATING
 *     ITERATING              = EPS_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 * 
 * class EPSPowerShiftType(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSConvergedReason(EPS_CONVERGED_ITERATING); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ITERATING, __pyx_t_4) < 0) __PYX_ERR(17, 193, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":176
 *     USER  = EPS_STOP_USER
 * 
 * class EPSConvergedReason(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS convergence reasons
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EPSConvergedReason, __pyx_tuple__31, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 176, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSConvergedReason, __pyx_t_4) < 0) __PYX_ERR(17, 176, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/EPS.pyx":195
 *     ITERATING              = EPS_CONVERGED_ITERATING
 * 
 * class EPSPowerShiftType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS Power shift type.
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__32); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 195, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__32, __pyx_n_s_EPSPowerShiftType, __pyx_n_s_EPSPowerShiftType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_EPS_Power_shift_type_CONSTANT_C); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 195, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/EPS.pyx":203
 *     - `WILKINSON`: Wilkinson shift.
 *     """
 *     CONSTANT  = EPS_POWER_SHIFT_CONSTANT             # <<<<<<<<<<<<<<
 *     RAYLEIGH  = EPS_POWER_SHIFT_RAYLEIGH
 *     WILKINSON = EPS_POWER_SHIFT_WILKINSON
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSPowerShiftType(EPS_POWER_SHIFT_CONSTANT); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 203, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONSTANT, __pyx_t_4) < 0) __PYX_ERR(17, 203, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":204
 *     """
 *     CONSTANT  = EPS_POWER_SHIFT_CONSTANT
 *     RAYLEIGH  = EPS_POWER_SHIFT_RAYLEIGH             # <<<<<<<<<<<<<<
 *     WILKINSON = EPS_POWER_SHIFT_WILKINSON
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSPowerShiftType(EPS_POWER_SHIFT_RAYLEIGH); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 204, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RAYLEIGH, __pyx_t_4) < 0) __PYX_ERR(17, 204, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":205
 *     CONSTANT  = EPS_POWER_SHIFT_CONSTANT
 *     RAYLEIGH  = EPS_POWER_SHIFT_RAYLEIGH
 *     WILKINSON = EPS_POWER_SHIFT_WILKINSON             # <<<<<<<<<<<<<<
 * 
 * class EPSLanczosReorthogType(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSPowerShiftType(EPS_POWER_SHIFT_WILKINSON); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_WILKINSON, __pyx_t_4) < 0) __PYX_ERR(17, 205, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":195
 *     ITERATING              = EPS_CONVERGED_ITERATING
 * 
 * class EPSPowerShiftType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS Power shift type.
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EPSPowerShiftType, __pyx_tuple__32, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 195, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSPowerShiftType, __pyx_t_4) < 0) __PYX_ERR(17, 195, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/EPS.pyx":207
 *     WILKINSON = EPS_POWER_SHIFT_WILKINSON
 * 
 * class EPSLanczosReorthogType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS Lanczos reorthogonalization type
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__33); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 207, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__33, __pyx_n_s_EPSLanczosReorthogType, __pyx_n_s_EPSLanczosReorthogType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_EPS_Lanczos_reorthogonalization); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 207, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/EPS.pyx":218
 *     - `DELAYED`:   Delayed reorthogonalization.
 *     """
 *     LOCAL     = EPS_LANCZOS_REORTHOG_LOCAL             # <<<<<<<<<<<<<<
 *     FULL      = EPS_LANCZOS_REORTHOG_FULL
 *     SELECTIVE = EPS_LANCZOS_REORTHOG_SELECTIVE
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSLanczosReorthogType(EPS_LANCZOS_REORTHOG_LOCAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LOCAL, __pyx_t_4) < 0) __PYX_ERR(17, 218, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":219
 *     """
 *     LOCAL     = EPS_LANCZOS_REORTHOG_LOCAL
 *     FULL      = EPS_LANCZOS_REORTHOG_FULL             # <<<<<<<<<<<<<<
 *     SELECTIVE = EPS_LANCZOS_REORTHOG_SELECTIVE
 *     PERIODIC  = EPS_LANCZOS_REORTHOG_PERIODIC
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSLanczosReorthogType(EPS_LANCZOS_REORTHOG_FULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 219, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_FULL, __pyx_t_4) < 0) __PYX_ERR(17, 219, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":220
 *     LOCAL     = EPS_LANCZOS_REORTHOG_LOCAL
 *     FULL      = EPS_LANCZOS_REORTHOG_FULL
 *     SELECTIVE = EPS_LANCZOS_REORTHOG_SELECTIVE             # <<<<<<<<<<<<<<
 *     PERIODIC  = EPS_LANCZOS_REORTHOG_PERIODIC
 *     PARTIAL   = EPS_LANCZOS_REORTHOG_PARTIAL
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSLanczosReorthogType(EPS_LANCZOS_REORTHOG_SELECTIVE); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SELECTIVE, __pyx_t_4) < 0) __PYX_ERR(17, 220, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":221
 *     FULL      = EPS_LANCZOS_REORTHOG_FULL
 *     SELECTIVE = EPS_LANCZOS_REORTHOG_SELECTIVE
 *     PERIODIC  = EPS_LANCZOS_REORTHOG_PERIODIC             # <<<<<<<<<<<<<<
 *     PARTIAL   = EPS_LANCZOS_REORTHOG_PARTIAL
 *     DELAYED   = EPS_LANCZOS_REORTHOG_DELAYED
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSLanczosReorthogType(EPS_LANCZOS_REORTHOG_PERIODIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_PERIODIC, __pyx_t_4) < 0) __PYX_ERR(17, 221, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":222
 *     SELECTIVE = EPS_LANCZOS_REORTHOG_SELECTIVE
 *     PERIODIC  = EPS_LANCZOS_REORTHOG_PERIODIC
 *     PARTIAL   = EPS_LANCZOS_REORTHOG_PARTIAL             # <<<<<<<<<<<<<<
 *     DELAYED   = EPS_LANCZOS_REORTHOG_DELAYED
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSLanczosReorthogType(EPS_LANCZOS_REORTHOG_PARTIAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_PARTIAL, __pyx_t_4) < 0) __PYX_ERR(17, 222, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":223
 *     PERIODIC  = EPS_LANCZOS_REORTHOG_PERIODIC
 *     PARTIAL   = EPS_LANCZOS_REORTHOG_PARTIAL
 *     DELAYED   = EPS_LANCZOS_REORTHOG_DELAYED             # <<<<<<<<<<<<<<
 * 
 * class EPSCISSQuadRule(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSLanczosReorthogType(EPS_LANCZOS_REORTHOG_DELAYED); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 223, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DELAYED, __pyx_t_4) < 0) __PYX_ERR(17, 223, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":207
 *     WILKINSON = EPS_POWER_SHIFT_WILKINSON
 * 
 * class EPSLanczosReorthogType(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS Lanczos reorthogonalization type
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EPSLanczosReorthogType, __pyx_tuple__33, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 207, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSLanczosReorthogType, __pyx_t_4) < 0) __PYX_ERR(17, 207, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/EPS.pyx":225
 *     DELAYED   = EPS_LANCZOS_REORTHOG_DELAYED
 * 
 * class EPSCISSQuadRule(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS CISS quadrature rule
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__34); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__34, __pyx_n_s_EPSCISSQuadRule, __pyx_n_s_EPSCISSQuadRule, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_EPS_CISS_quadrature_rule_TRAPEZ); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/EPS.pyx":232
 *     - `CHEBYSHEV`:   Chebyshev points.
 *     """
 *     TRAPEZOIDAL = EPS_CISS_QUADRULE_TRAPEZOIDAL             # <<<<<<<<<<<<<<
 *     CHEBYSHEV   = EPS_CISS_QUADRULE_CHEBYSHEV
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSCISSQuadRule(EPS_CISS_QUADRULE_TRAPEZOIDAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 232, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TRAPEZOIDAL, __pyx_t_4) < 0) __PYX_ERR(17, 232, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":233
 *     """
 *     TRAPEZOIDAL = EPS_CISS_QUADRULE_TRAPEZOIDAL
 *     CHEBYSHEV   = EPS_CISS_QUADRULE_CHEBYSHEV             # <<<<<<<<<<<<<<
 * 
 * class EPSCISSExtraction(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSCISSQuadRule(EPS_CISS_QUADRULE_CHEBYSHEV); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 233, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CHEBYSHEV, __pyx_t_4) < 0) __PYX_ERR(17, 233, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":225
 *     DELAYED   = EPS_LANCZOS_REORTHOG_DELAYED
 * 
 * class EPSCISSQuadRule(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS CISS quadrature rule
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EPSCISSQuadRule, __pyx_tuple__34, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSCISSQuadRule, __pyx_t_4) < 0) __PYX_ERR(17, 225, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/EPS.pyx":235
 *     CHEBYSHEV   = EPS_CISS_QUADRULE_CHEBYSHEV
 * 
 * class EPSCISSExtraction(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS CISS extraction technique
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__35); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 235, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__35, __pyx_n_s_EPSCISSExtraction, __pyx_n_s_EPSCISSExtraction, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_EPS_CISS_extraction_technique_R); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 235, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/EPS.pyx":242
 *     - `HANKEL`: Extraction via Hankel eigenproblem.
 *     """
 *     RITZ   = EPS_CISS_EXTRACTION_RITZ             # <<<<<<<<<<<<<<
 *     HANKEL = EPS_CISS_EXTRACTION_HANKEL
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSCISSExtraction(EPS_CISS_EXTRACTION_RITZ); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 242, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RITZ, __pyx_t_4) < 0) __PYX_ERR(17, 242, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":243
 *     """
 *     RITZ   = EPS_CISS_EXTRACTION_RITZ
 *     HANKEL = EPS_CISS_EXTRACTION_HANKEL             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_4 = __Pyx_PyInt_From_EPSCISSExtraction(EPS_CISS_EXTRACTION_HANKEL); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 243, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_HANKEL, __pyx_t_4) < 0) __PYX_ERR(17, 243, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/EPS.pyx":235
 *     CHEBYSHEV   = EPS_CISS_QUADRULE_CHEBYSHEV
 * 
 * class EPSCISSExtraction(object):             # <<<<<<<<<<<<<<
 *     """
 *     EPS CISS extraction technique
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_EPSCISSExtraction, __pyx_tuple__35, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 235, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSCISSExtraction, __pyx_t_4) < 0) __PYX_ERR(17, 235, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/EPS.pyx":253
 *     """
 * 
 *     Type            = EPSType             # <<<<<<<<<<<<<<
 *     ProblemType     = EPSProblemType
 *     Extraction      = EPSExtraction
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_EPSType); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 253, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS->tp_dict, __pyx_n_s_Type, __pyx_t_2) < 0) __PYX_ERR(17, 253, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_EPS);

  /* "SLEPc/EPS.pyx":254
 * 
 *     Type            = EPSType
 *     ProblemType     = EPSProblemType             # <<<<<<<<<<<<<<
 *     Extraction      = EPSExtraction
 *     Balance         = EPSBalance
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_EPSProblemType); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 254, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS->tp_dict, __pyx_n_s_ProblemType, __pyx_t_2) < 0) __PYX_ERR(17, 254, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_EPS);

  /* "SLEPc/EPS.pyx":255
 *     Type            = EPSType
 *     ProblemType     = EPSProblemType
 *     Extraction      = EPSExtraction             # <<<<<<<<<<<<<<
 *     Balance         = EPSBalance
 *     ErrorType       = EPSErrorType
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_EPSExtraction); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 255, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS->tp_dict, __pyx_n_s_Extraction, __pyx_t_2) < 0) __PYX_ERR(17, 255, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_EPS);

  /* "SLEPc/EPS.pyx":256
 *     ProblemType     = EPSProblemType
 *     Extraction      = EPSExtraction
 *     Balance         = EPSBalance             # <<<<<<<<<<<<<<
 *     ErrorType       = EPSErrorType
 *     Which           = EPSWhich
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_EPSBalance); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 256, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS->tp_dict, __pyx_n_s_Balance, __pyx_t_2) < 0) __PYX_ERR(17, 256, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_EPS);

  /* "SLEPc/EPS.pyx":257
 *     Extraction      = EPSExtraction
 *     Balance         = EPSBalance
 *     ErrorType       = EPSErrorType             # <<<<<<<<<<<<<<
 *     Which           = EPSWhich
 *     Conv            = EPSConv
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_EPSErrorType); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 257, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS->tp_dict, __pyx_n_s_ErrorType, __pyx_t_2) < 0) __PYX_ERR(17, 257, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_EPS);

  /* "SLEPc/EPS.pyx":258
 *     Balance         = EPSBalance
 *     ErrorType       = EPSErrorType
 *     Which           = EPSWhich             # <<<<<<<<<<<<<<
 *     Conv            = EPSConv
 *     Stop            = EPSStop
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_EPSWhich); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 258, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS->tp_dict, __pyx_n_s_Which, __pyx_t_2) < 0) __PYX_ERR(17, 258, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_EPS);

  /* "SLEPc/EPS.pyx":259
 *     ErrorType       = EPSErrorType
 *     Which           = EPSWhich
 *     Conv            = EPSConv             # <<<<<<<<<<<<<<
 *     Stop            = EPSStop
 *     ConvergedReason = EPSConvergedReason
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_EPSConv); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 259, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS->tp_dict, __pyx_n_s_Conv, __pyx_t_2) < 0) __PYX_ERR(17, 259, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_EPS);

  /* "SLEPc/EPS.pyx":260
 *     Which           = EPSWhich
 *     Conv            = EPSConv
 *     Stop            = EPSStop             # <<<<<<<<<<<<<<
 *     ConvergedReason = EPSConvergedReason
 * 
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_EPSStop); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 260, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS->tp_dict, __pyx_n_s_Stop, __pyx_t_2) < 0) __PYX_ERR(17, 260, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_EPS);

  /* "SLEPc/EPS.pyx":261
 *     Conv            = EPSConv
 *     Stop            = EPSStop
 *     ConvergedReason = EPSConvergedReason             # <<<<<<<<<<<<<<
 * 
 *     PowerShiftType      = EPSPowerShiftType
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_EPSConvergedReason); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 261, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS->tp_dict, __pyx_n_s_ConvergedReason, __pyx_t_2) < 0) __PYX_ERR(17, 261, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_EPS);

  /* "SLEPc/EPS.pyx":263
 *     ConvergedReason = EPSConvergedReason
 * 
 *     PowerShiftType      = EPSPowerShiftType             # <<<<<<<<<<<<<<
 *     LanczosReorthogType = EPSLanczosReorthogType
 *     CISSQuadRule        = EPSCISSQuadRule
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_EPSPowerShiftType); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 263, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS->tp_dict, __pyx_n_s_PowerShiftType, __pyx_t_2) < 0) __PYX_ERR(17, 263, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_EPS);

  /* "SLEPc/EPS.pyx":264
 * 
 *     PowerShiftType      = EPSPowerShiftType
 *     LanczosReorthogType = EPSLanczosReorthogType             # <<<<<<<<<<<<<<
 *     CISSQuadRule        = EPSCISSQuadRule
 *     CISSExtraction      = EPSCISSExtraction
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_EPSLanczosReorthogType); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 264, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS->tp_dict, __pyx_n_s_LanczosReorthogType, __pyx_t_2) < 0) __PYX_ERR(17, 264, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_EPS);

  /* "SLEPc/EPS.pyx":265
 *     PowerShiftType      = EPSPowerShiftType
 *     LanczosReorthogType = EPSLanczosReorthogType
 *     CISSQuadRule        = EPSCISSQuadRule             # <<<<<<<<<<<<<<
 *     CISSExtraction      = EPSCISSExtraction
 * 
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_EPSCISSQuadRule); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 265, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS->tp_dict, __pyx_n_s_CISSQuadRule, __pyx_t_2) < 0) __PYX_ERR(17, 265, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_EPS);

  /* "SLEPc/EPS.pyx":266
 *     LanczosReorthogType = EPSLanczosReorthogType
 *     CISSQuadRule        = EPSCISSQuadRule
 *     CISSExtraction      = EPSCISSExtraction             # <<<<<<<<<<<<<<
 * 
 *     def __cinit__(self):
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_EPSCISSExtraction); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 266, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_EPS->tp_dict, __pyx_n_s_CISSExtraction, __pyx_t_2) < 0) __PYX_ERR(17, 266, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_EPS);

  /* "SLEPc/EPS.pyx":2931
 * # -----------------------------------------------------------------------------
 * 
 * del EPSType             # <<<<<<<<<<<<<<
 * del EPSProblemType
 * del EPSExtraction
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_EPSType) < 0) __PYX_ERR(17, 2931, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2932
 * 
 * del EPSType
 * del EPSProblemType             # <<<<<<<<<<<<<<
 * del EPSExtraction
 * del EPSBalance
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_EPSProblemType) < 0) __PYX_ERR(17, 2932, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2933
 * del EPSType
 * del EPSProblemType
 * del EPSExtraction             # <<<<<<<<<<<<<<
 * del EPSBalance
 * del EPSErrorType
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_EPSExtraction) < 0) __PYX_ERR(17, 2933, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2934
 * del EPSProblemType
 * del EPSExtraction
 * del EPSBalance             # <<<<<<<<<<<<<<
 * del EPSErrorType
 * del EPSWhich
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_EPSBalance) < 0) __PYX_ERR(17, 2934, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2935
 * del EPSExtraction
 * del EPSBalance
 * del EPSErrorType             # <<<<<<<<<<<<<<
 * del EPSWhich
 * del EPSConv
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_EPSErrorType) < 0) __PYX_ERR(17, 2935, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2936
 * del EPSBalance
 * del EPSErrorType
 * del EPSWhich             # <<<<<<<<<<<<<<
 * del EPSConv
 * del EPSStop
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_EPSWhich) < 0) __PYX_ERR(17, 2936, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2937
 * del EPSErrorType
 * del EPSWhich
 * del EPSConv             # <<<<<<<<<<<<<<
 * del EPSStop
 * del EPSConvergedReason
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_EPSConv) < 0) __PYX_ERR(17, 2937, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2938
 * del EPSWhich
 * del EPSConv
 * del EPSStop             # <<<<<<<<<<<<<<
 * del EPSConvergedReason
 * del EPSPowerShiftType
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_EPSStop) < 0) __PYX_ERR(17, 2938, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2939
 * del EPSConv
 * del EPSStop
 * del EPSConvergedReason             # <<<<<<<<<<<<<<
 * del EPSPowerShiftType
 * del EPSLanczosReorthogType
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_EPSConvergedReason) < 0) __PYX_ERR(17, 2939, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2940
 * del EPSStop
 * del EPSConvergedReason
 * del EPSPowerShiftType             # <<<<<<<<<<<<<<
 * del EPSLanczosReorthogType
 * del EPSCISSQuadRule
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_EPSPowerShiftType) < 0) __PYX_ERR(17, 2940, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2941
 * del EPSConvergedReason
 * del EPSPowerShiftType
 * del EPSLanczosReorthogType             # <<<<<<<<<<<<<<
 * del EPSCISSQuadRule
 * del EPSCISSExtraction
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_EPSLanczosReorthogType) < 0) __PYX_ERR(17, 2941, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2942
 * del EPSPowerShiftType
 * del EPSLanczosReorthogType
 * del EPSCISSQuadRule             # <<<<<<<<<<<<<<
 * del EPSCISSExtraction
 * 
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_EPSCISSQuadRule) < 0) __PYX_ERR(17, 2942, __pyx_L1_error)

  /* "SLEPc/EPS.pyx":2943
 * del EPSLanczosReorthogType
 * del EPSCISSQuadRule
 * del EPSCISSExtraction             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_EPSCISSExtraction) < 0) __PYX_ERR(17, 2943, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class SVDType(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD types
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__36); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__36, __pyx_n_s_SVDType, __pyx_n_s_SVDType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_SVD_types_CROSS_Eigenproblem_wi); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/SVD.pyx":21
 *     - `PRIMME`:
 *     """
 *     CROSS      = S_(SVDCROSS)             # <<<<<<<<<<<<<<
 *     CYCLIC     = S_(SVDCYCLIC)
 *     LAPACK     = S_(SVDLAPACK)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(SVDCROSS); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 21, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CROSS, __pyx_t_4) < 0) __PYX_ERR(18, 21, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":22
 *     """
 *     CROSS      = S_(SVDCROSS)
 *     CYCLIC     = S_(SVDCYCLIC)             # <<<<<<<<<<<<<<
 *     LAPACK     = S_(SVDLAPACK)
 *     LANCZOS    = S_(SVDLANCZOS)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(SVDCYCLIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 22, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CYCLIC, __pyx_t_4) < 0) __PYX_ERR(18, 22, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":23
 *     CROSS      = S_(SVDCROSS)
 *     CYCLIC     = S_(SVDCYCLIC)
 *     LAPACK     = S_(SVDLAPACK)             # <<<<<<<<<<<<<<
 *     LANCZOS    = S_(SVDLANCZOS)
 *     TRLANCZOS  = S_(SVDTRLANCZOS)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(SVDLAPACK); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LAPACK, __pyx_t_4) < 0) __PYX_ERR(18, 23, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":24
 *     CYCLIC     = S_(SVDCYCLIC)
 *     LAPACK     = S_(SVDLAPACK)
 *     LANCZOS    = S_(SVDLANCZOS)             # <<<<<<<<<<<<<<
 *     TRLANCZOS  = S_(SVDTRLANCZOS)
 *     RANDOMIZED = S_(SVDRANDOMIZED)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(SVDLANCZOS); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 24, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LANCZOS, __pyx_t_4) < 0) __PYX_ERR(18, 24, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":25
 *     LAPACK     = S_(SVDLAPACK)
 *     LANCZOS    = S_(SVDLANCZOS)
 *     TRLANCZOS  = S_(SVDTRLANCZOS)             # <<<<<<<<<<<<<<
 *     RANDOMIZED = S_(SVDRANDOMIZED)
 *     SCALAPACK  = S_(SVDSCALAPACK)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(SVDTRLANCZOS); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 25, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TRLANCZOS, __pyx_t_4) < 0) __PYX_ERR(18, 25, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":26
 *     LANCZOS    = S_(SVDLANCZOS)
 *     TRLANCZOS  = S_(SVDTRLANCZOS)
 *     RANDOMIZED = S_(SVDRANDOMIZED)             # <<<<<<<<<<<<<<
 *     SCALAPACK  = S_(SVDSCALAPACK)
 *     ELEMENTAL  = S_(SVDELEMENTAL)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(SVDRANDOMIZED); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 26, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RANDOMIZED, __pyx_t_4) < 0) __PYX_ERR(18, 26, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":27
 *     TRLANCZOS  = S_(SVDTRLANCZOS)
 *     RANDOMIZED = S_(SVDRANDOMIZED)
 *     SCALAPACK  = S_(SVDSCALAPACK)             # <<<<<<<<<<<<<<
 *     ELEMENTAL  = S_(SVDELEMENTAL)
 *     PRIMME     = S_(SVDPRIMME)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(SVDSCALAPACK); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 27, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SCALAPACK, __pyx_t_4) < 0) __PYX_ERR(18, 27, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":28
 *     RANDOMIZED = S_(SVDRANDOMIZED)
 *     SCALAPACK  = S_(SVDSCALAPACK)
 *     ELEMENTAL  = S_(SVDELEMENTAL)             # <<<<<<<<<<<<<<
 *     PRIMME     = S_(SVDPRIMME)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(SVDELEMENTAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 28, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ELEMENTAL, __pyx_t_4) < 0) __PYX_ERR(18, 28, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":29
 *     SCALAPACK  = S_(SVDSCALAPACK)
 *     ELEMENTAL  = S_(SVDELEMENTAL)
 *     PRIMME     = S_(SVDPRIMME)             # <<<<<<<<<<<<<<
 * 
 * class SVDProblemType(object):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(SVDPRIMME); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 29, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_PRIMME, __pyx_t_4) < 0) __PYX_ERR(18, 29, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class SVDType(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD types
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SVDType, __pyx_tuple__36, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SVDType, __pyx_t_4) < 0) __PYX_ERR(18, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/SVD.pyx":31
 *     PRIMME     = S_(SVDPRIMME)
 * 
 * class SVDProblemType(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD problem type
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__37); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 31, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__37, __pyx_n_s_SVDProblemType, __pyx_n_s_SVDProblemType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_SVD_problem_type_STANDARD_Stand); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 31, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/SVD.pyx":39
 *     - `HYPERBOLIC` : Hyperbolic singular value decomposition (HSVD).
 *     """
 *     STANDARD    = SVD_STANDARD             # <<<<<<<<<<<<<<
 *     GENERALIZED = SVD_GENERALIZED
 *     HYPERBOLIC  = SVD_HYPERBOLIC
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDProblemType(SVD_STANDARD); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 39, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_STANDARD, __pyx_t_4) < 0) __PYX_ERR(18, 39, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":40
 *     """
 *     STANDARD    = SVD_STANDARD
 *     GENERALIZED = SVD_GENERALIZED             # <<<<<<<<<<<<<<
 *     HYPERBOLIC  = SVD_HYPERBOLIC
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDProblemType(SVD_GENERALIZED); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 40, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_GENERALIZED, __pyx_t_4) < 0) __PYX_ERR(18, 40, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":41
 *     STANDARD    = SVD_STANDARD
 *     GENERALIZED = SVD_GENERALIZED
 *     HYPERBOLIC  = SVD_HYPERBOLIC             # <<<<<<<<<<<<<<
 * 
 * class SVDErrorType(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDProblemType(SVD_HYPERBOLIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 41, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_HYPERBOLIC, __pyx_t_4) < 0) __PYX_ERR(18, 41, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":31
 *     PRIMME     = S_(SVDPRIMME)
 * 
 * class SVDProblemType(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD problem type
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SVDProblemType, __pyx_tuple__37, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 31, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SVDProblemType, __pyx_t_4) < 0) __PYX_ERR(18, 31, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/SVD.pyx":43
 *     HYPERBOLIC  = SVD_HYPERBOLIC
 * 
 * class SVDErrorType(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD error type to assess accuracy of computed solutions
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__38); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 43, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__38, __pyx_n_s_SVDErrorType, __pyx_n_s_SVDErrorType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_SVD_error_type_to_assess_accura); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 43, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/SVD.pyx":51
 *     - `NORM`:     Error relative to the matrix norm.
 *     """
 *     ABSOLUTE = SVD_ERROR_ABSOLUTE             # <<<<<<<<<<<<<<
 *     RELATIVE = SVD_ERROR_RELATIVE
 *     NORM     = SVD_ERROR_NORM
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDErrorType(SVD_ERROR_ABSOLUTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ABSOLUTE, __pyx_t_4) < 0) __PYX_ERR(18, 51, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":52
 *     """
 *     ABSOLUTE = SVD_ERROR_ABSOLUTE
 *     RELATIVE = SVD_ERROR_RELATIVE             # <<<<<<<<<<<<<<
 *     NORM     = SVD_ERROR_NORM
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDErrorType(SVD_ERROR_RELATIVE); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RELATIVE, __pyx_t_4) < 0) __PYX_ERR(18, 52, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":53
 *     ABSOLUTE = SVD_ERROR_ABSOLUTE
 *     RELATIVE = SVD_ERROR_RELATIVE
 *     NORM     = SVD_ERROR_NORM             # <<<<<<<<<<<<<<
 * 
 * class SVDWhich(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDErrorType(SVD_ERROR_NORM); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 53, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NORM, __pyx_t_4) < 0) __PYX_ERR(18, 53, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":43
 *     HYPERBOLIC  = SVD_HYPERBOLIC
 * 
 * class SVDErrorType(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD error type to assess accuracy of computed solutions
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SVDErrorType, __pyx_tuple__38, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 43, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SVDErrorType, __pyx_t_4) < 0) __PYX_ERR(18, 43, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/SVD.pyx":55
 *     NORM     = SVD_ERROR_NORM
 * 
 * class SVDWhich(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD desired part of spectrum
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__39); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__39, __pyx_n_s_SVDWhich, __pyx_n_s_SVDWhich, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_SVD_desired_part_of_spectrum_LA); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/SVD.pyx":62
 *     - `SMALLEST`: Smallest singular values.
 *     """
 *     LARGEST  = SVD_LARGEST             # <<<<<<<<<<<<<<
 *     SMALLEST = SVD_SMALLEST
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDWhich(SVD_LARGEST); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 62, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LARGEST, __pyx_t_4) < 0) __PYX_ERR(18, 62, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":63
 *     """
 *     LARGEST  = SVD_LARGEST
 *     SMALLEST = SVD_SMALLEST             # <<<<<<<<<<<<<<
 * 
 * class SVDConv(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDWhich(SVD_SMALLEST); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 63, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SMALLEST, __pyx_t_4) < 0) __PYX_ERR(18, 63, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":55
 *     NORM     = SVD_ERROR_NORM
 * 
 * class SVDWhich(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD desired part of spectrum
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SVDWhich, __pyx_tuple__39, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SVDWhich, __pyx_t_4) < 0) __PYX_ERR(18, 55, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/SVD.pyx":65
 *     SMALLEST = SVD_SMALLEST
 * 
 * class SVDConv(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD convergence test
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__40); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 65, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__40, __pyx_n_s_SVDConv, __pyx_n_s_SVDConv, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_SVD_convergence_test_ABS_Absolu); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 65, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/SVD.pyx":75
 *     - `USER`:  User-defined convergence test.
 *     """
 *     ABS   = SVD_CONV_ABS             # <<<<<<<<<<<<<<
 *     REL   = SVD_CONV_REL
 *     NORM  = SVD_CONV_NORM
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDConv(SVD_CONV_ABS); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 75, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ABS, __pyx_t_4) < 0) __PYX_ERR(18, 75, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":76
 *     """
 *     ABS   = SVD_CONV_ABS
 *     REL   = SVD_CONV_REL             # <<<<<<<<<<<<<<
 *     NORM  = SVD_CONV_NORM
 *     MAXIT = SVD_CONV_MAXIT
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDConv(SVD_CONV_REL); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 76, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_REL, __pyx_t_4) < 0) __PYX_ERR(18, 76, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":77
 *     ABS   = SVD_CONV_ABS
 *     REL   = SVD_CONV_REL
 *     NORM  = SVD_CONV_NORM             # <<<<<<<<<<<<<<
 *     MAXIT = SVD_CONV_MAXIT
 *     USER  = SVD_CONV_USER
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDConv(SVD_CONV_NORM); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 77, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NORM, __pyx_t_4) < 0) __PYX_ERR(18, 77, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":78
 *     REL   = SVD_CONV_REL
 *     NORM  = SVD_CONV_NORM
 *     MAXIT = SVD_CONV_MAXIT             # <<<<<<<<<<<<<<
 *     USER  = SVD_CONV_USER
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDConv(SVD_CONV_MAXIT); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 78, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_MAXIT, __pyx_t_4) < 0) __PYX_ERR(18, 78, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":79
 *     NORM  = SVD_CONV_NORM
 *     MAXIT = SVD_CONV_MAXIT
 *     USER  = SVD_CONV_USER             # <<<<<<<<<<<<<<
 * 
 * class SVDStop(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDConv(SVD_CONV_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 79, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_USER, __pyx_t_4) < 0) __PYX_ERR(18, 79, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":65
 *     SMALLEST = SVD_SMALLEST
 * 
 * class SVDConv(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD convergence test
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SVDConv, __pyx_tuple__40, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 65, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SVDConv, __pyx_t_4) < 0) __PYX_ERR(18, 65, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/SVD.pyx":81
 *     USER  = SVD_CONV_USER
 * 
 * class SVDStop(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD stopping test
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__41); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 81, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__41, __pyx_n_s_SVDStop, __pyx_n_s_SVDStop, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_SVD_stopping_test_BASIC_Default); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 81, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/SVD.pyx":88
 *     - `USER`:  User-defined stopping test.
 *     """
 *     BASIC = SVD_STOP_BASIC             # <<<<<<<<<<<<<<
 *     USER  = SVD_STOP_USER
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDStop(SVD_STOP_BASIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 88, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_BASIC, __pyx_t_4) < 0) __PYX_ERR(18, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":89
 *     """
 *     BASIC = SVD_STOP_BASIC
 *     USER  = SVD_STOP_USER             # <<<<<<<<<<<<<<
 * 
 * class SVDConvergedReason(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDStop(SVD_STOP_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 89, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_USER, __pyx_t_4) < 0) __PYX_ERR(18, 89, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":81
 *     USER  = SVD_CONV_USER
 * 
 * class SVDStop(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD stopping test
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SVDStop, __pyx_tuple__41, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 81, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SVDStop, __pyx_t_4) < 0) __PYX_ERR(18, 81, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/SVD.pyx":91
 *     USER  = SVD_STOP_USER
 * 
 * class SVDConvergedReason(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD convergence reasons
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__42); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 91, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__42, __pyx_n_s_SVDConvergedReason, __pyx_n_s_SVDConvergedReason, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_SVD_convergence_reasons_CONVERG); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 91, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/SVD.pyx":102
 *     - `CONVERGED_ITERATING`: Iteration not finished yet.
 *     """
 *     CONVERGED_TOL       = SVD_CONVERGED_TOL             # <<<<<<<<<<<<<<
 *     CONVERGED_USER      = SVD_CONVERGED_USER
 *     CONVERGED_MAXIT     = SVD_CONVERGED_MAXIT
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDConvergedReason(SVD_CONVERGED_TOL); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 102, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_TOL, __pyx_t_4) < 0) __PYX_ERR(18, 102, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":103
 *     """
 *     CONVERGED_TOL       = SVD_CONVERGED_TOL
 *     CONVERGED_USER      = SVD_CONVERGED_USER             # <<<<<<<<<<<<<<
 *     CONVERGED_MAXIT     = SVD_CONVERGED_MAXIT
 *     DIVERGED_ITS        = SVD_DIVERGED_ITS
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDConvergedReason(SVD_CONVERGED_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 103, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_USER, __pyx_t_4) < 0) __PYX_ERR(18, 103, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":104
 *     CONVERGED_TOL       = SVD_CONVERGED_TOL
 *     CONVERGED_USER      = SVD_CONVERGED_USER
 *     CONVERGED_MAXIT     = SVD_CONVERGED_MAXIT             # <<<<<<<<<<<<<<
 *     DIVERGED_ITS        = SVD_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN  = SVD_DIVERGED_BREAKDOWN
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDConvergedReason(SVD_CONVERGED_MAXIT); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 104, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_MAXIT, __pyx_t_4) < 0) __PYX_ERR(18, 104, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":105
 *     CONVERGED_USER      = SVD_CONVERGED_USER
 *     CONVERGED_MAXIT     = SVD_CONVERGED_MAXIT
 *     DIVERGED_ITS        = SVD_DIVERGED_ITS             # <<<<<<<<<<<<<<
 *     DIVERGED_BREAKDOWN  = SVD_DIVERGED_BREAKDOWN
 *     CONVERGED_ITERATING = SVD_CONVERGED_ITERATING
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDConvergedReason(SVD_DIVERGED_ITS); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 105, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVERGED_ITS, __pyx_t_4) < 0) __PYX_ERR(18, 105, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":106
 *     CONVERGED_MAXIT     = SVD_CONVERGED_MAXIT
 *     DIVERGED_ITS        = SVD_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN  = SVD_DIVERGED_BREAKDOWN             # <<<<<<<<<<<<<<
 *     CONVERGED_ITERATING = SVD_CONVERGED_ITERATING
 *     ITERATING           = SVD_CONVERGED_ITERATING
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDConvergedReason(SVD_DIVERGED_BREAKDOWN); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 106, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVERGED_BREAKDOWN, __pyx_t_4) < 0) __PYX_ERR(18, 106, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":107
 *     DIVERGED_ITS        = SVD_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN  = SVD_DIVERGED_BREAKDOWN
 *     CONVERGED_ITERATING = SVD_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *     ITERATING           = SVD_CONVERGED_ITERATING
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDConvergedReason(SVD_CONVERGED_ITERATING); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_ITERATING, __pyx_t_4) < 0) __PYX_ERR(18, 107, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":108
 *     DIVERGED_BREAKDOWN  = SVD_DIVERGED_BREAKDOWN
 *     CONVERGED_ITERATING = SVD_CONVERGED_ITERATING
 *     ITERATING           = SVD_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 * 
 * class SVDTRLanczosGBidiag(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDConvergedReason(SVD_CONVERGED_ITERATING); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 108, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ITERATING, __pyx_t_4) < 0) __PYX_ERR(18, 108, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":91
 *     USER  = SVD_STOP_USER
 * 
 * class SVDConvergedReason(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD convergence reasons
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SVDConvergedReason, __pyx_tuple__42, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 91, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SVDConvergedReason, __pyx_t_4) < 0) __PYX_ERR(18, 91, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/SVD.pyx":110
 *     ITERATING           = SVD_CONVERGED_ITERATING
 * 
 * class SVDTRLanczosGBidiag(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD TRLanczos bidiagonalization choices for the GSVD case
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__43); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 110, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__43, __pyx_n_s_SVDTRLanczosGBidiag, __pyx_n_s_SVDTRLanczosGBidiag, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_SVD_TRLanczos_bidiagonalization); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 110, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/SVD.pyx":118
 *     - `LOWER`:  Joint bidiagonalization, Qa lower bidiagonal, Qb upper bidiagonal.
 *     """
 *     SINGLE = SVD_TRLANCZOS_GBIDIAG_SINGLE             # <<<<<<<<<<<<<<
 *     UPPER  = SVD_TRLANCZOS_GBIDIAG_UPPER
 *     LOWER  = SVD_TRLANCZOS_GBIDIAG_LOWER
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDTRLanczosGBidiag(SVD_TRLANCZOS_GBIDIAG_SINGLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 118, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SINGLE, __pyx_t_4) < 0) __PYX_ERR(18, 118, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":119
 *     """
 *     SINGLE = SVD_TRLANCZOS_GBIDIAG_SINGLE
 *     UPPER  = SVD_TRLANCZOS_GBIDIAG_UPPER             # <<<<<<<<<<<<<<
 *     LOWER  = SVD_TRLANCZOS_GBIDIAG_LOWER
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDTRLanczosGBidiag(SVD_TRLANCZOS_GBIDIAG_UPPER); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_UPPER, __pyx_t_4) < 0) __PYX_ERR(18, 119, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":120
 *     SINGLE = SVD_TRLANCZOS_GBIDIAG_SINGLE
 *     UPPER  = SVD_TRLANCZOS_GBIDIAG_UPPER
 *     LOWER  = SVD_TRLANCZOS_GBIDIAG_LOWER             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_4 = __Pyx_PyInt_From_SVDTRLanczosGBidiag(SVD_TRLANCZOS_GBIDIAG_LOWER); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 120, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LOWER, __pyx_t_4) < 0) __PYX_ERR(18, 120, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/SVD.pyx":110
 *     ITERATING           = SVD_CONVERGED_ITERATING
 * 
 * class SVDTRLanczosGBidiag(object):             # <<<<<<<<<<<<<<
 *     """
 *     SVD TRLanczos bidiagonalization choices for the GSVD case
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_SVDTRLanczosGBidiag, __pyx_tuple__43, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(18, 110, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SVDTRLanczosGBidiag, __pyx_t_4) < 0) __PYX_ERR(18, 110, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/SVD.pyx":130
 *     """
 * 
 *     Type            = SVDType             # <<<<<<<<<<<<<<
 *     ProblemType     = SVDProblemType
 *     ErrorType       = SVDErrorType
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SVDType); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_SVD->tp_dict, __pyx_n_s_Type, __pyx_t_2) < 0) __PYX_ERR(18, 130, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_SVD);

  /* "SLEPc/SVD.pyx":131
 * 
 *     Type            = SVDType
 *     ProblemType     = SVDProblemType             # <<<<<<<<<<<<<<
 *     ErrorType       = SVDErrorType
 *     Which           = SVDWhich
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SVDProblemType); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_SVD->tp_dict, __pyx_n_s_ProblemType, __pyx_t_2) < 0) __PYX_ERR(18, 131, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_SVD);

  /* "SLEPc/SVD.pyx":132
 *     Type            = SVDType
 *     ProblemType     = SVDProblemType
 *     ErrorType       = SVDErrorType             # <<<<<<<<<<<<<<
 *     Which           = SVDWhich
 *     Conv            = SVDConv
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SVDErrorType); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 132, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_SVD->tp_dict, __pyx_n_s_ErrorType, __pyx_t_2) < 0) __PYX_ERR(18, 132, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_SVD);

  /* "SLEPc/SVD.pyx":133
 *     ProblemType     = SVDProblemType
 *     ErrorType       = SVDErrorType
 *     Which           = SVDWhich             # <<<<<<<<<<<<<<
 *     Conv            = SVDConv
 *     Stop            = SVDStop
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SVDWhich); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 133, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_SVD->tp_dict, __pyx_n_s_Which, __pyx_t_2) < 0) __PYX_ERR(18, 133, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_SVD);

  /* "SLEPc/SVD.pyx":134
 *     ErrorType       = SVDErrorType
 *     Which           = SVDWhich
 *     Conv            = SVDConv             # <<<<<<<<<<<<<<
 *     Stop            = SVDStop
 *     ConvergedReason = SVDConvergedReason
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SVDConv); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 134, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_SVD->tp_dict, __pyx_n_s_Conv, __pyx_t_2) < 0) __PYX_ERR(18, 134, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_SVD);

  /* "SLEPc/SVD.pyx":135
 *     Which           = SVDWhich
 *     Conv            = SVDConv
 *     Stop            = SVDStop             # <<<<<<<<<<<<<<
 *     ConvergedReason = SVDConvergedReason
 * 
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SVDStop); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 135, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_SVD->tp_dict, __pyx_n_s_Stop, __pyx_t_2) < 0) __PYX_ERR(18, 135, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_SVD);

  /* "SLEPc/SVD.pyx":136
 *     Conv            = SVDConv
 *     Stop            = SVDStop
 *     ConvergedReason = SVDConvergedReason             # <<<<<<<<<<<<<<
 * 
 *     TRLanczosGBidiag = SVDTRLanczosGBidiag
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SVDConvergedReason); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 136, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_SVD->tp_dict, __pyx_n_s_ConvergedReason, __pyx_t_2) < 0) __PYX_ERR(18, 136, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_SVD);

  /* "SLEPc/SVD.pyx":138
 *     ConvergedReason = SVDConvergedReason
 * 
 *     TRLanczosGBidiag = SVDTRLanczosGBidiag             # <<<<<<<<<<<<<<
 * 
 *     def __cinit__(self):
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SVDTRLanczosGBidiag); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 138, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_SVD->tp_dict, __pyx_n_s_TRLanczosGBidiag, __pyx_t_2) < 0) __PYX_ERR(18, 138, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_SVD);

  /* "SLEPc/SVD.pyx":1318
 *         return toBool(tval)
 * 
 *     setOperator = setOperators  # backward compatibility             # <<<<<<<<<<<<<<
 * 
 *     #
 */
  __Pyx_GetNameInClass(__pyx_t_2, (PyObject *)__pyx_ptype_8slepc4py_5SLEPc_SVD, __pyx_n_s_setOperators); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 1318, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_SVD->tp_dict, __pyx_n_s_setOperator, __pyx_t_2) < 0) __PYX_ERR(18, 1318, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_SVD);

  /* "SLEPc/SVD.pyx":1366
 * # -----------------------------------------------------------------------------
 * 
 * del SVDType             # <<<<<<<<<<<<<<
 * del SVDProblemType
 * del SVDErrorType
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_SVDType) < 0) __PYX_ERR(18, 1366, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1367
 * 
 * del SVDType
 * del SVDProblemType             # <<<<<<<<<<<<<<
 * del SVDErrorType
 * del SVDWhich
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_SVDProblemType) < 0) __PYX_ERR(18, 1367, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1368
 * del SVDType
 * del SVDProblemType
 * del SVDErrorType             # <<<<<<<<<<<<<<
 * del SVDWhich
 * del SVDConv
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_SVDErrorType) < 0) __PYX_ERR(18, 1368, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1369
 * del SVDProblemType
 * del SVDErrorType
 * del SVDWhich             # <<<<<<<<<<<<<<
 * del SVDConv
 * del SVDStop
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_SVDWhich) < 0) __PYX_ERR(18, 1369, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1370
 * del SVDErrorType
 * del SVDWhich
 * del SVDConv             # <<<<<<<<<<<<<<
 * del SVDStop
 * del SVDConvergedReason
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_SVDConv) < 0) __PYX_ERR(18, 1370, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1371
 * del SVDWhich
 * del SVDConv
 * del SVDStop             # <<<<<<<<<<<<<<
 * del SVDConvergedReason
 * del SVDTRLanczosGBidiag
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_SVDStop) < 0) __PYX_ERR(18, 1371, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1372
 * del SVDConv
 * del SVDStop
 * del SVDConvergedReason             # <<<<<<<<<<<<<<
 * del SVDTRLanczosGBidiag
 * 
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_SVDConvergedReason) < 0) __PYX_ERR(18, 1372, __pyx_L1_error)

  /* "SLEPc/SVD.pyx":1373
 * del SVDStop
 * del SVDConvergedReason
 * del SVDTRLanczosGBidiag             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_SVDTRLanczosGBidiag) < 0) __PYX_ERR(18, 1373, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class PEPType(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP type
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__44); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__44, __pyx_n_s_PEPType, __pyx_n_s_PEPType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_PEP_type_Polynomial_eigensolver); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/PEP.pyx":16
 *     - `CISS`:     Contour integral spectrum slice.
 *     """
 *     LINEAR   = S_(PEPLINEAR)             # <<<<<<<<<<<<<<
 *     QARNOLDI = S_(PEPQARNOLDI)
 *     TOAR     = S_(PEPTOAR)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(PEPLINEAR); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 16, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LINEAR, __pyx_t_4) < 0) __PYX_ERR(19, 16, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":17
 *     """
 *     LINEAR   = S_(PEPLINEAR)
 *     QARNOLDI = S_(PEPQARNOLDI)             # <<<<<<<<<<<<<<
 *     TOAR     = S_(PEPTOAR)
 *     STOAR    = S_(PEPSTOAR)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(PEPQARNOLDI); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_QARNOLDI, __pyx_t_4) < 0) __PYX_ERR(19, 17, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":18
 *     LINEAR   = S_(PEPLINEAR)
 *     QARNOLDI = S_(PEPQARNOLDI)
 *     TOAR     = S_(PEPTOAR)             # <<<<<<<<<<<<<<
 *     STOAR    = S_(PEPSTOAR)
 *     JD       = S_(PEPJD)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(PEPTOAR); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TOAR, __pyx_t_4) < 0) __PYX_ERR(19, 18, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":19
 *     QARNOLDI = S_(PEPQARNOLDI)
 *     TOAR     = S_(PEPTOAR)
 *     STOAR    = S_(PEPSTOAR)             # <<<<<<<<<<<<<<
 *     JD       = S_(PEPJD)
 *     CISS     = S_(PEPCISS)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(PEPSTOAR); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 19, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_STOAR, __pyx_t_4) < 0) __PYX_ERR(19, 19, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":20
 *     TOAR     = S_(PEPTOAR)
 *     STOAR    = S_(PEPSTOAR)
 *     JD       = S_(PEPJD)             # <<<<<<<<<<<<<<
 *     CISS     = S_(PEPCISS)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(PEPJD); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 20, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_JD, __pyx_t_4) < 0) __PYX_ERR(19, 20, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":21
 *     STOAR    = S_(PEPSTOAR)
 *     JD       = S_(PEPJD)
 *     CISS     = S_(PEPCISS)             # <<<<<<<<<<<<<<
 * 
 * class PEPProblemType(object):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(PEPCISS); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 21, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CISS, __pyx_t_4) < 0) __PYX_ERR(19, 21, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class PEPType(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP type
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PEPType, __pyx_tuple__44, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PEPType, __pyx_t_4) < 0) __PYX_ERR(19, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":23
 *     CISS     = S_(PEPCISS)
 * 
 * class PEPProblemType(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP problem type
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__45); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__45, __pyx_n_s_PEPProblemType, __pyx_n_s_PEPProblemType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_PEP_problem_type_GENERAL_No_str); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/PEP.pyx":32
 *     - `GYROSCOPIC`: QEP with M, K  Hermitian, M>0, C skew-Hermitian.
 *     """
 *     GENERAL    = PEP_GENERAL             # <<<<<<<<<<<<<<
 *     HERMITIAN  = PEP_HERMITIAN
 *     HYPERBOLIC = PEP_HYPERBOLIC
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPProblemType(PEP_GENERAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 32, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_GENERAL, __pyx_t_4) < 0) __PYX_ERR(19, 32, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":33
 *     """
 *     GENERAL    = PEP_GENERAL
 *     HERMITIAN  = PEP_HERMITIAN             # <<<<<<<<<<<<<<
 *     HYPERBOLIC = PEP_HYPERBOLIC
 *     GYROSCOPIC = PEP_GYROSCOPIC
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPProblemType(PEP_HERMITIAN); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 33, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_HERMITIAN, __pyx_t_4) < 0) __PYX_ERR(19, 33, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":34
 *     GENERAL    = PEP_GENERAL
 *     HERMITIAN  = PEP_HERMITIAN
 *     HYPERBOLIC = PEP_HYPERBOLIC             # <<<<<<<<<<<<<<
 *     GYROSCOPIC = PEP_GYROSCOPIC
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPProblemType(PEP_HYPERBOLIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 34, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_HYPERBOLIC, __pyx_t_4) < 0) __PYX_ERR(19, 34, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":35
 *     HERMITIAN  = PEP_HERMITIAN
 *     HYPERBOLIC = PEP_HYPERBOLIC
 *     GYROSCOPIC = PEP_GYROSCOPIC             # <<<<<<<<<<<<<<
 * 
 * class PEPWhich(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPProblemType(PEP_GYROSCOPIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 35, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_GYROSCOPIC, __pyx_t_4) < 0) __PYX_ERR(19, 35, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":23
 *     CISS     = S_(PEPCISS)
 * 
 * class PEPProblemType(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP problem type
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PEPProblemType, __pyx_tuple__45, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PEPProblemType, __pyx_t_4) < 0) __PYX_ERR(19, 23, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":37
 *     GYROSCOPIC = PEP_GYROSCOPIC
 * 
 * class PEPWhich(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP desired part of spectrum
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__46); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 37, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__46, __pyx_n_s_PEPWhich, __pyx_n_s_PEPWhich, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_PEP_desired_part_of_spectrum_LA); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 37, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/PEP.pyx":53
 *     - `USER`:               User-defined criterion.
 *     """
 *     LARGEST_MAGNITUDE  = PEP_LARGEST_MAGNITUDE             # <<<<<<<<<<<<<<
 *     SMALLEST_MAGNITUDE = PEP_SMALLEST_MAGNITUDE
 *     LARGEST_REAL       = PEP_LARGEST_REAL
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPWhich(PEP_LARGEST_MAGNITUDE); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 53, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LARGEST_MAGNITUDE, __pyx_t_4) < 0) __PYX_ERR(19, 53, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":54
 *     """
 *     LARGEST_MAGNITUDE  = PEP_LARGEST_MAGNITUDE
 *     SMALLEST_MAGNITUDE = PEP_SMALLEST_MAGNITUDE             # <<<<<<<<<<<<<<
 *     LARGEST_REAL       = PEP_LARGEST_REAL
 *     SMALLEST_REAL      = PEP_SMALLEST_REAL
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPWhich(PEP_SMALLEST_MAGNITUDE); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 54, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SMALLEST_MAGNITUDE, __pyx_t_4) < 0) __PYX_ERR(19, 54, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":55
 *     LARGEST_MAGNITUDE  = PEP_LARGEST_MAGNITUDE
 *     SMALLEST_MAGNITUDE = PEP_SMALLEST_MAGNITUDE
 *     LARGEST_REAL       = PEP_LARGEST_REAL             # <<<<<<<<<<<<<<
 *     SMALLEST_REAL      = PEP_SMALLEST_REAL
 *     LARGEST_IMAGINARY  = PEP_LARGEST_IMAGINARY
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPWhich(PEP_LARGEST_REAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LARGEST_REAL, __pyx_t_4) < 0) __PYX_ERR(19, 55, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":56
 *     SMALLEST_MAGNITUDE = PEP_SMALLEST_MAGNITUDE
 *     LARGEST_REAL       = PEP_LARGEST_REAL
 *     SMALLEST_REAL      = PEP_SMALLEST_REAL             # <<<<<<<<<<<<<<
 *     LARGEST_IMAGINARY  = PEP_LARGEST_IMAGINARY
 *     SMALLEST_IMAGINARY = PEP_SMALLEST_IMAGINARY
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPWhich(PEP_SMALLEST_REAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 56, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SMALLEST_REAL, __pyx_t_4) < 0) __PYX_ERR(19, 56, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":57
 *     LARGEST_REAL       = PEP_LARGEST_REAL
 *     SMALLEST_REAL      = PEP_SMALLEST_REAL
 *     LARGEST_IMAGINARY  = PEP_LARGEST_IMAGINARY             # <<<<<<<<<<<<<<
 *     SMALLEST_IMAGINARY = PEP_SMALLEST_IMAGINARY
 *     TARGET_MAGNITUDE   = PEP_TARGET_MAGNITUDE
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPWhich(PEP_LARGEST_IMAGINARY); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 57, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LARGEST_IMAGINARY, __pyx_t_4) < 0) __PYX_ERR(19, 57, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":58
 *     SMALLEST_REAL      = PEP_SMALLEST_REAL
 *     LARGEST_IMAGINARY  = PEP_LARGEST_IMAGINARY
 *     SMALLEST_IMAGINARY = PEP_SMALLEST_IMAGINARY             # <<<<<<<<<<<<<<
 *     TARGET_MAGNITUDE   = PEP_TARGET_MAGNITUDE
 *     TARGET_REAL        = PEP_TARGET_REAL
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPWhich(PEP_SMALLEST_IMAGINARY); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 58, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SMALLEST_IMAGINARY, __pyx_t_4) < 0) __PYX_ERR(19, 58, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":59
 *     LARGEST_IMAGINARY  = PEP_LARGEST_IMAGINARY
 *     SMALLEST_IMAGINARY = PEP_SMALLEST_IMAGINARY
 *     TARGET_MAGNITUDE   = PEP_TARGET_MAGNITUDE             # <<<<<<<<<<<<<<
 *     TARGET_REAL        = PEP_TARGET_REAL
 *     TARGET_IMAGINARY   = PEP_TARGET_IMAGINARY
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPWhich(PEP_TARGET_MAGNITUDE); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 59, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TARGET_MAGNITUDE, __pyx_t_4) < 0) __PYX_ERR(19, 59, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":60
 *     SMALLEST_IMAGINARY = PEP_SMALLEST_IMAGINARY
 *     TARGET_MAGNITUDE   = PEP_TARGET_MAGNITUDE
 *     TARGET_REAL        = PEP_TARGET_REAL             # <<<<<<<<<<<<<<
 *     TARGET_IMAGINARY   = PEP_TARGET_IMAGINARY
 *     ALL                = PEP_ALL
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPWhich(PEP_TARGET_REAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 60, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TARGET_REAL, __pyx_t_4) < 0) __PYX_ERR(19, 60, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":61
 *     TARGET_MAGNITUDE   = PEP_TARGET_MAGNITUDE
 *     TARGET_REAL        = PEP_TARGET_REAL
 *     TARGET_IMAGINARY   = PEP_TARGET_IMAGINARY             # <<<<<<<<<<<<<<
 *     ALL                = PEP_ALL
 *     USER               = PEP_WHICH_USER
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPWhich(PEP_TARGET_IMAGINARY); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TARGET_IMAGINARY, __pyx_t_4) < 0) __PYX_ERR(19, 61, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":62
 *     TARGET_REAL        = PEP_TARGET_REAL
 *     TARGET_IMAGINARY   = PEP_TARGET_IMAGINARY
 *     ALL                = PEP_ALL             # <<<<<<<<<<<<<<
 *     USER               = PEP_WHICH_USER
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPWhich(PEP_ALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 62, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ALL, __pyx_t_4) < 0) __PYX_ERR(19, 62, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":63
 *     TARGET_IMAGINARY   = PEP_TARGET_IMAGINARY
 *     ALL                = PEP_ALL
 *     USER               = PEP_WHICH_USER             # <<<<<<<<<<<<<<
 * 
 * class PEPBasis(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPWhich(PEP_WHICH_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 63, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_USER, __pyx_t_4) < 0) __PYX_ERR(19, 63, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":37
 *     GYROSCOPIC = PEP_GYROSCOPIC
 * 
 * class PEPWhich(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP desired part of spectrum
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PEPWhich, __pyx_tuple__46, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 37, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PEPWhich, __pyx_t_4) < 0) __PYX_ERR(19, 37, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":65
 *     USER               = PEP_WHICH_USER
 * 
 * class PEPBasis(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP basis type for the representation of the polynomial
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__47); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 65, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__47, __pyx_n_s_PEPBasis, __pyx_n_s_PEPBasis, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_PEP_basis_type_for_the_represen); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 65, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/PEP.pyx":76
 *     - `HERMITE`:    Hermite polynomials.
 *     """
 *     MONOMIAL   = PEP_BASIS_MONOMIAL             # <<<<<<<<<<<<<<
 *     CHEBYSHEV1 = PEP_BASIS_CHEBYSHEV1
 *     CHEBYSHEV2 = PEP_BASIS_CHEBYSHEV2
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPBasis(PEP_BASIS_MONOMIAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 76, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_MONOMIAL, __pyx_t_4) < 0) __PYX_ERR(19, 76, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":77
 *     """
 *     MONOMIAL   = PEP_BASIS_MONOMIAL
 *     CHEBYSHEV1 = PEP_BASIS_CHEBYSHEV1             # <<<<<<<<<<<<<<
 *     CHEBYSHEV2 = PEP_BASIS_CHEBYSHEV2
 *     LEGENDRE   = PEP_BASIS_LEGENDRE
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPBasis(PEP_BASIS_CHEBYSHEV1); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 77, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CHEBYSHEV1, __pyx_t_4) < 0) __PYX_ERR(19, 77, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":78
 *     MONOMIAL   = PEP_BASIS_MONOMIAL
 *     CHEBYSHEV1 = PEP_BASIS_CHEBYSHEV1
 *     CHEBYSHEV2 = PEP_BASIS_CHEBYSHEV2             # <<<<<<<<<<<<<<
 *     LEGENDRE   = PEP_BASIS_LEGENDRE
 *     LAGUERRE   = PEP_BASIS_LAGUERRE
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPBasis(PEP_BASIS_CHEBYSHEV2); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 78, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CHEBYSHEV2, __pyx_t_4) < 0) __PYX_ERR(19, 78, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":79
 *     CHEBYSHEV1 = PEP_BASIS_CHEBYSHEV1
 *     CHEBYSHEV2 = PEP_BASIS_CHEBYSHEV2
 *     LEGENDRE   = PEP_BASIS_LEGENDRE             # <<<<<<<<<<<<<<
 *     LAGUERRE   = PEP_BASIS_LAGUERRE
 *     HERMITE    = PEP_BASIS_HERMITE
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPBasis(PEP_BASIS_LEGENDRE); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 79, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LEGENDRE, __pyx_t_4) < 0) __PYX_ERR(19, 79, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":80
 *     CHEBYSHEV2 = PEP_BASIS_CHEBYSHEV2
 *     LEGENDRE   = PEP_BASIS_LEGENDRE
 *     LAGUERRE   = PEP_BASIS_LAGUERRE             # <<<<<<<<<<<<<<
 *     HERMITE    = PEP_BASIS_HERMITE
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPBasis(PEP_BASIS_LAGUERRE); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 80, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LAGUERRE, __pyx_t_4) < 0) __PYX_ERR(19, 80, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":81
 *     LEGENDRE   = PEP_BASIS_LEGENDRE
 *     LAGUERRE   = PEP_BASIS_LAGUERRE
 *     HERMITE    = PEP_BASIS_HERMITE             # <<<<<<<<<<<<<<
 * 
 * class PEPScale(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPBasis(PEP_BASIS_HERMITE); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 81, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_HERMITE, __pyx_t_4) < 0) __PYX_ERR(19, 81, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":65
 *     USER               = PEP_WHICH_USER
 * 
 * class PEPBasis(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP basis type for the representation of the polynomial
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PEPBasis, __pyx_tuple__47, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 65, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PEPBasis, __pyx_t_4) < 0) __PYX_ERR(19, 65, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":83
 *     HERMITE    = PEP_BASIS_HERMITE
 * 
 * class PEPScale(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP scaling strategy
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__48); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 83, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__48, __pyx_n_s_PEPScale, __pyx_n_s_PEPScale, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_PEP_scaling_strategy_NONE_No_sc); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 83, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/PEP.pyx":92
 *     - `BOTH`:     Both parameter and diagonal scaling.
 *     """
 *     NONE     = PEP_SCALE_NONE             # <<<<<<<<<<<<<<
 *     SCALAR   = PEP_SCALE_SCALAR
 *     DIAGONAL = PEP_SCALE_DIAGONAL
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPScale(PEP_SCALE_NONE); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 92, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NONE, __pyx_t_4) < 0) __PYX_ERR(19, 92, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":93
 *     """
 *     NONE     = PEP_SCALE_NONE
 *     SCALAR   = PEP_SCALE_SCALAR             # <<<<<<<<<<<<<<
 *     DIAGONAL = PEP_SCALE_DIAGONAL
 *     BOTH     = PEP_SCALE_BOTH
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPScale(PEP_SCALE_SCALAR); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 93, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SCALAR, __pyx_t_4) < 0) __PYX_ERR(19, 93, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":94
 *     NONE     = PEP_SCALE_NONE
 *     SCALAR   = PEP_SCALE_SCALAR
 *     DIAGONAL = PEP_SCALE_DIAGONAL             # <<<<<<<<<<<<<<
 *     BOTH     = PEP_SCALE_BOTH
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPScale(PEP_SCALE_DIAGONAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 94, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIAGONAL, __pyx_t_4) < 0) __PYX_ERR(19, 94, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":95
 *     SCALAR   = PEP_SCALE_SCALAR
 *     DIAGONAL = PEP_SCALE_DIAGONAL
 *     BOTH     = PEP_SCALE_BOTH             # <<<<<<<<<<<<<<
 * 
 * class PEPRefine(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPScale(PEP_SCALE_BOTH); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 95, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_BOTH, __pyx_t_4) < 0) __PYX_ERR(19, 95, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":83
 *     HERMITE    = PEP_BASIS_HERMITE
 * 
 * class PEPScale(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP scaling strategy
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PEPScale, __pyx_tuple__48, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 83, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PEPScale, __pyx_t_4) < 0) __PYX_ERR(19, 83, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":97
 *     BOTH     = PEP_SCALE_BOTH
 * 
 * class PEPRefine(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP refinement strategy
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__49); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__49, __pyx_n_s_PEPRefine, __pyx_n_s_PEPRefine, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_PEP_refinement_strategy_NONE_No); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/PEP.pyx":105
 *     - `MULTIPLE`: Refine all eigenpairs simultaneously (invariant pair).
 *     """
 *     NONE     = PEP_REFINE_NONE             # <<<<<<<<<<<<<<
 *     SIMPLE   = PEP_REFINE_SIMPLE
 *     MULTIPLE = PEP_REFINE_MULTIPLE
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPRefine(PEP_REFINE_NONE); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 105, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NONE, __pyx_t_4) < 0) __PYX_ERR(19, 105, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":106
 *     """
 *     NONE     = PEP_REFINE_NONE
 *     SIMPLE   = PEP_REFINE_SIMPLE             # <<<<<<<<<<<<<<
 *     MULTIPLE = PEP_REFINE_MULTIPLE
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPRefine(PEP_REFINE_SIMPLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 106, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SIMPLE, __pyx_t_4) < 0) __PYX_ERR(19, 106, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":107
 *     NONE     = PEP_REFINE_NONE
 *     SIMPLE   = PEP_REFINE_SIMPLE
 *     MULTIPLE = PEP_REFINE_MULTIPLE             # <<<<<<<<<<<<<<
 * 
 * class PEPRefineScheme(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPRefine(PEP_REFINE_MULTIPLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 107, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_MULTIPLE, __pyx_t_4) < 0) __PYX_ERR(19, 107, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":97
 *     BOTH     = PEP_SCALE_BOTH
 * 
 * class PEPRefine(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP refinement strategy
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PEPRefine, __pyx_tuple__49, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PEPRefine, __pyx_t_4) < 0) __PYX_ERR(19, 97, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":109
 *     MULTIPLE = PEP_REFINE_MULTIPLE
 * 
 * class PEPRefineScheme(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP scheme for solving linear systems during iterative refinement
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__50); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 109, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__50, __pyx_n_s_PEPRefineScheme, __pyx_n_s_PEPRefineScheme, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_PEP_scheme_for_solving_linear_s); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 109, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/PEP.pyx":117
 *     - `EXPLICIT`: Build the explicit matrix.
 *     """
 *     SCHUR    = PEP_REFINE_SCHEME_SCHUR             # <<<<<<<<<<<<<<
 *     MBE      = PEP_REFINE_SCHEME_MBE
 *     EXPLICIT = PEP_REFINE_SCHEME_EXPLICIT
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPRefineScheme(PEP_REFINE_SCHEME_SCHUR); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 117, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SCHUR, __pyx_t_4) < 0) __PYX_ERR(19, 117, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":118
 *     """
 *     SCHUR    = PEP_REFINE_SCHEME_SCHUR
 *     MBE      = PEP_REFINE_SCHEME_MBE             # <<<<<<<<<<<<<<
 *     EXPLICIT = PEP_REFINE_SCHEME_EXPLICIT
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPRefineScheme(PEP_REFINE_SCHEME_MBE); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 118, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_MBE, __pyx_t_4) < 0) __PYX_ERR(19, 118, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":119
 *     SCHUR    = PEP_REFINE_SCHEME_SCHUR
 *     MBE      = PEP_REFINE_SCHEME_MBE
 *     EXPLICIT = PEP_REFINE_SCHEME_EXPLICIT             # <<<<<<<<<<<<<<
 * 
 * class PEPExtract(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPRefineScheme(PEP_REFINE_SCHEME_EXPLICIT); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_EXPLICIT, __pyx_t_4) < 0) __PYX_ERR(19, 119, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":109
 *     MULTIPLE = PEP_REFINE_MULTIPLE
 * 
 * class PEPRefineScheme(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP scheme for solving linear systems during iterative refinement
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PEPRefineScheme, __pyx_tuple__50, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 109, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PEPRefineScheme, __pyx_t_4) < 0) __PYX_ERR(19, 109, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":121
 *     EXPLICIT = PEP_REFINE_SCHEME_EXPLICIT
 * 
 * class PEPExtract(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP extraction strategy used to obtain eigenvectors of the PEP from the
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__51); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 121, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__51, __pyx_n_s_PEPExtract, __pyx_n_s_PEPExtract, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_PEP_extraction_strategy_used_to); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 121, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/PEP.pyx":131
 *     - `STRUCTURED`: Combine all blocks in a certain way.
 *     """
 *     NONE       = PEP_EXTRACT_NONE             # <<<<<<<<<<<<<<
 *     NORM       = PEP_EXTRACT_NORM
 *     RESIDUAL   = PEP_EXTRACT_RESIDUAL
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPExtract(PEP_EXTRACT_NONE); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NONE, __pyx_t_4) < 0) __PYX_ERR(19, 131, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":132
 *     """
 *     NONE       = PEP_EXTRACT_NONE
 *     NORM       = PEP_EXTRACT_NORM             # <<<<<<<<<<<<<<
 *     RESIDUAL   = PEP_EXTRACT_RESIDUAL
 *     STRUCTURED = PEP_EXTRACT_STRUCTURED
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPExtract(PEP_EXTRACT_NORM); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 132, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NORM, __pyx_t_4) < 0) __PYX_ERR(19, 132, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":133
 *     NONE       = PEP_EXTRACT_NONE
 *     NORM       = PEP_EXTRACT_NORM
 *     RESIDUAL   = PEP_EXTRACT_RESIDUAL             # <<<<<<<<<<<<<<
 *     STRUCTURED = PEP_EXTRACT_STRUCTURED
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPExtract(PEP_EXTRACT_RESIDUAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 133, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RESIDUAL, __pyx_t_4) < 0) __PYX_ERR(19, 133, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":134
 *     NORM       = PEP_EXTRACT_NORM
 *     RESIDUAL   = PEP_EXTRACT_RESIDUAL
 *     STRUCTURED = PEP_EXTRACT_STRUCTURED             # <<<<<<<<<<<<<<
 * 
 * class PEPErrorType(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPExtract(PEP_EXTRACT_STRUCTURED); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 134, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_STRUCTURED, __pyx_t_4) < 0) __PYX_ERR(19, 134, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":121
 *     EXPLICIT = PEP_REFINE_SCHEME_EXPLICIT
 * 
 * class PEPExtract(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP extraction strategy used to obtain eigenvectors of the PEP from the
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PEPExtract, __pyx_tuple__51, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 121, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PEPExtract, __pyx_t_4) < 0) __PYX_ERR(19, 121, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":136
 *     STRUCTURED = PEP_EXTRACT_STRUCTURED
 * 
 * class PEPErrorType(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP error type to assess accuracy of computed solutions
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__52); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 136, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__52, __pyx_n_s_PEPErrorType, __pyx_n_s_PEPErrorType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_PEP_error_type_to_assess_accura); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 136, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/PEP.pyx":144
 *     - `BACKWARD`: Backward error.
 *     """
 *     ABSOLUTE = PEP_ERROR_ABSOLUTE             # <<<<<<<<<<<<<<
 *     RELATIVE = PEP_ERROR_RELATIVE
 *     BACKWARD = PEP_ERROR_BACKWARD
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPErrorType(PEP_ERROR_ABSOLUTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 144, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ABSOLUTE, __pyx_t_4) < 0) __PYX_ERR(19, 144, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":145
 *     """
 *     ABSOLUTE = PEP_ERROR_ABSOLUTE
 *     RELATIVE = PEP_ERROR_RELATIVE             # <<<<<<<<<<<<<<
 *     BACKWARD = PEP_ERROR_BACKWARD
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPErrorType(PEP_ERROR_RELATIVE); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 145, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RELATIVE, __pyx_t_4) < 0) __PYX_ERR(19, 145, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":146
 *     ABSOLUTE = PEP_ERROR_ABSOLUTE
 *     RELATIVE = PEP_ERROR_RELATIVE
 *     BACKWARD = PEP_ERROR_BACKWARD             # <<<<<<<<<<<<<<
 * 
 * class PEPConv(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPErrorType(PEP_ERROR_BACKWARD); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 146, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_BACKWARD, __pyx_t_4) < 0) __PYX_ERR(19, 146, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":136
 *     STRUCTURED = PEP_EXTRACT_STRUCTURED
 * 
 * class PEPErrorType(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP error type to assess accuracy of computed solutions
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PEPErrorType, __pyx_tuple__52, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 136, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PEPErrorType, __pyx_t_4) < 0) __PYX_ERR(19, 136, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":148
 *     BACKWARD = PEP_ERROR_BACKWARD
 * 
 * class PEPConv(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP convergence test
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__53); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 148, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__53, __pyx_n_s_PEPConv, __pyx_n_s_PEPConv, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_PEP_convergence_test_ABS_Absolu); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 148, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/PEP.pyx":157
 *     - `USER`: User-defined convergence test.
 *     """
 *     ABS  = PEP_CONV_ABS             # <<<<<<<<<<<<<<
 *     REL  = PEP_CONV_REL
 *     NORM = PEP_CONV_NORM
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPConv(PEP_CONV_ABS); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 157, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ABS, __pyx_t_4) < 0) __PYX_ERR(19, 157, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":158
 *     """
 *     ABS  = PEP_CONV_ABS
 *     REL  = PEP_CONV_REL             # <<<<<<<<<<<<<<
 *     NORM = PEP_CONV_NORM
 *     USER = PEP_CONV_USER
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPConv(PEP_CONV_REL); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 158, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_REL, __pyx_t_4) < 0) __PYX_ERR(19, 158, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":159
 *     ABS  = PEP_CONV_ABS
 *     REL  = PEP_CONV_REL
 *     NORM = PEP_CONV_NORM             # <<<<<<<<<<<<<<
 *     USER = PEP_CONV_USER
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPConv(PEP_CONV_NORM); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 159, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NORM, __pyx_t_4) < 0) __PYX_ERR(19, 159, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":160
 *     REL  = PEP_CONV_REL
 *     NORM = PEP_CONV_NORM
 *     USER = PEP_CONV_USER             # <<<<<<<<<<<<<<
 * 
 * class PEPStop(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPConv(PEP_CONV_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_USER, __pyx_t_4) < 0) __PYX_ERR(19, 160, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":148
 *     BACKWARD = PEP_ERROR_BACKWARD
 * 
 * class PEPConv(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP convergence test
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PEPConv, __pyx_tuple__53, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 148, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PEPConv, __pyx_t_4) < 0) __PYX_ERR(19, 148, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":162
 *     USER = PEP_CONV_USER
 * 
 * class PEPStop(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP stopping test
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__54); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 162, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__54, __pyx_n_s_PEPStop, __pyx_n_s_PEPStop, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_PEP_stopping_test_BASIC_Default); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 162, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/PEP.pyx":169
 *     - `USER`:  User-defined stopping test.
 *     """
 *     BASIC = PEP_STOP_BASIC             # <<<<<<<<<<<<<<
 *     USER  = PEP_STOP_USER
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPStop(PEP_STOP_BASIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 169, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_BASIC, __pyx_t_4) < 0) __PYX_ERR(19, 169, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":170
 *     """
 *     BASIC = PEP_STOP_BASIC
 *     USER  = PEP_STOP_USER             # <<<<<<<<<<<<<<
 * 
 * class PEPConvergedReason(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPStop(PEP_STOP_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 170, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_USER, __pyx_t_4) < 0) __PYX_ERR(19, 170, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":162
 *     USER = PEP_CONV_USER
 * 
 * class PEPStop(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP stopping test
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PEPStop, __pyx_tuple__54, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 162, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PEPStop, __pyx_t_4) < 0) __PYX_ERR(19, 162, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":172
 *     USER  = PEP_STOP_USER
 * 
 * class PEPConvergedReason(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP convergence reasons
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__55); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__55, __pyx_n_s_PEPConvergedReason, __pyx_n_s_PEPConvergedReason, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_PEP_convergence_reasons_CONVERG); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/PEP.pyx":183
 *     - `CONVERGED_ITERATING`:    Iteration not finished yet.
 *     """
 *     CONVERGED_TOL          = PEP_CONVERGED_TOL             # <<<<<<<<<<<<<<
 *     CONVERGED_USER         = PEP_CONVERGED_USER
 *     DIVERGED_ITS           = PEP_DIVERGED_ITS
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPConvergedReason(PEP_CONVERGED_TOL); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 183, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_TOL, __pyx_t_4) < 0) __PYX_ERR(19, 183, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":184
 *     """
 *     CONVERGED_TOL          = PEP_CONVERGED_TOL
 *     CONVERGED_USER         = PEP_CONVERGED_USER             # <<<<<<<<<<<<<<
 *     DIVERGED_ITS           = PEP_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN     = PEP_DIVERGED_BREAKDOWN
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPConvergedReason(PEP_CONVERGED_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 184, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_USER, __pyx_t_4) < 0) __PYX_ERR(19, 184, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":185
 *     CONVERGED_TOL          = PEP_CONVERGED_TOL
 *     CONVERGED_USER         = PEP_CONVERGED_USER
 *     DIVERGED_ITS           = PEP_DIVERGED_ITS             # <<<<<<<<<<<<<<
 *     DIVERGED_BREAKDOWN     = PEP_DIVERGED_BREAKDOWN
 *     DIVERGED_SYMMETRY_LOST = PEP_DIVERGED_SYMMETRY_LOST
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPConvergedReason(PEP_DIVERGED_ITS); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 185, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVERGED_ITS, __pyx_t_4) < 0) __PYX_ERR(19, 185, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":186
 *     CONVERGED_USER         = PEP_CONVERGED_USER
 *     DIVERGED_ITS           = PEP_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN     = PEP_DIVERGED_BREAKDOWN             # <<<<<<<<<<<<<<
 *     DIVERGED_SYMMETRY_LOST = PEP_DIVERGED_SYMMETRY_LOST
 *     CONVERGED_ITERATING    = PEP_CONVERGED_ITERATING
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPConvergedReason(PEP_DIVERGED_BREAKDOWN); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 186, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVERGED_BREAKDOWN, __pyx_t_4) < 0) __PYX_ERR(19, 186, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":187
 *     DIVERGED_ITS           = PEP_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN     = PEP_DIVERGED_BREAKDOWN
 *     DIVERGED_SYMMETRY_LOST = PEP_DIVERGED_SYMMETRY_LOST             # <<<<<<<<<<<<<<
 *     CONVERGED_ITERATING    = PEP_CONVERGED_ITERATING
 *     ITERATING              = PEP_CONVERGED_ITERATING
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPConvergedReason(PEP_DIVERGED_SYMMETRY_LOST); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 187, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVERGED_SYMMETRY_LOST, __pyx_t_4) < 0) __PYX_ERR(19, 187, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":188
 *     DIVERGED_BREAKDOWN     = PEP_DIVERGED_BREAKDOWN
 *     DIVERGED_SYMMETRY_LOST = PEP_DIVERGED_SYMMETRY_LOST
 *     CONVERGED_ITERATING    = PEP_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *     ITERATING              = PEP_CONVERGED_ITERATING
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPConvergedReason(PEP_CONVERGED_ITERATING); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 188, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_ITERATING, __pyx_t_4) < 0) __PYX_ERR(19, 188, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":189
 *     DIVERGED_SYMMETRY_LOST = PEP_DIVERGED_SYMMETRY_LOST
 *     CONVERGED_ITERATING    = PEP_CONVERGED_ITERATING
 *     ITERATING              = PEP_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 * 
 * class PEPJDProjection(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPConvergedReason(PEP_CONVERGED_ITERATING); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 189, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ITERATING, __pyx_t_4) < 0) __PYX_ERR(19, 189, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":172
 *     USER  = PEP_STOP_USER
 * 
 * class PEPConvergedReason(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP convergence reasons
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PEPConvergedReason, __pyx_tuple__55, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PEPConvergedReason, __pyx_t_4) < 0) __PYX_ERR(19, 172, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":191
 *     ITERATING              = PEP_CONVERGED_ITERATING
 * 
 * class PEPJDProjection(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP type of projection to be used in the Jacobi-Davidson solver
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__56); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__56, __pyx_n_s_PEPJDProjection, __pyx_n_s_PEPJDProjection, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_PEP_type_of_projection_to_be_us); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/PEP.pyx":198
 *     - `ORTHOGONAL`: Orthogonal projection.
 *     """
 *     HARMONIC   = PEP_JD_PROJECTION_HARMONIC             # <<<<<<<<<<<<<<
 *     ORTHOGONAL = PEP_JD_PROJECTION_ORTHOGONAL
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPJDProjection(PEP_JD_PROJECTION_HARMONIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 198, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_HARMONIC, __pyx_t_4) < 0) __PYX_ERR(19, 198, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":199
 *     """
 *     HARMONIC   = PEP_JD_PROJECTION_HARMONIC
 *     ORTHOGONAL = PEP_JD_PROJECTION_ORTHOGONAL             # <<<<<<<<<<<<<<
 * 
 * class PEPCISSExtraction(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPJDProjection(PEP_JD_PROJECTION_ORTHOGONAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 199, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ORTHOGONAL, __pyx_t_4) < 0) __PYX_ERR(19, 199, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":191
 *     ITERATING              = PEP_CONVERGED_ITERATING
 * 
 * class PEPJDProjection(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP type of projection to be used in the Jacobi-Davidson solver
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PEPJDProjection, __pyx_tuple__56, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 191, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PEPJDProjection, __pyx_t_4) < 0) __PYX_ERR(19, 191, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":201
 *     ORTHOGONAL = PEP_JD_PROJECTION_ORTHOGONAL
 * 
 * class PEPCISSExtraction(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP CISS extraction technique
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__57); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__57, __pyx_n_s_PEPCISSExtraction, __pyx_n_s_PEPCISSExtraction, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_PEP_CISS_extraction_technique_R); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/PEP.pyx":209
 *     - `CAA`:    Communication-avoiding Arnoldi.
 *     """
 *     RITZ   = PEP_CISS_EXTRACTION_RITZ             # <<<<<<<<<<<<<<
 *     HANKEL = PEP_CISS_EXTRACTION_HANKEL
 *     CAA    = PEP_CISS_EXTRACTION_CAA
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPCISSExtraction(PEP_CISS_EXTRACTION_RITZ); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 209, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RITZ, __pyx_t_4) < 0) __PYX_ERR(19, 209, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":210
 *     """
 *     RITZ   = PEP_CISS_EXTRACTION_RITZ
 *     HANKEL = PEP_CISS_EXTRACTION_HANKEL             # <<<<<<<<<<<<<<
 *     CAA    = PEP_CISS_EXTRACTION_CAA
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPCISSExtraction(PEP_CISS_EXTRACTION_HANKEL); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 210, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_HANKEL, __pyx_t_4) < 0) __PYX_ERR(19, 210, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":211
 *     RITZ   = PEP_CISS_EXTRACTION_RITZ
 *     HANKEL = PEP_CISS_EXTRACTION_HANKEL
 *     CAA    = PEP_CISS_EXTRACTION_CAA             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_4 = __Pyx_PyInt_From_PEPCISSExtraction(PEP_CISS_EXTRACTION_CAA); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 211, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CAA, __pyx_t_4) < 0) __PYX_ERR(19, 211, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/PEP.pyx":201
 *     ORTHOGONAL = PEP_JD_PROJECTION_ORTHOGONAL
 * 
 * class PEPCISSExtraction(object):             # <<<<<<<<<<<<<<
 *     """
 *     PEP CISS extraction technique
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_PEPCISSExtraction, __pyx_tuple__57, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(19, 201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PEPCISSExtraction, __pyx_t_4) < 0) __PYX_ERR(19, 201, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/PEP.pyx":221
 *     """
 * 
 *     Type            = PEPType             # <<<<<<<<<<<<<<
 *     ProblemType     = PEPProblemType
 *     Which           = PEPWhich
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PEPType); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP->tp_dict, __pyx_n_s_Type, __pyx_t_2) < 0) __PYX_ERR(19, 221, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_PEP);

  /* "SLEPc/PEP.pyx":222
 * 
 *     Type            = PEPType
 *     ProblemType     = PEPProblemType             # <<<<<<<<<<<<<<
 *     Which           = PEPWhich
 *     Basis           = PEPBasis
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PEPProblemType); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP->tp_dict, __pyx_n_s_ProblemType, __pyx_t_2) < 0) __PYX_ERR(19, 222, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_PEP);

  /* "SLEPc/PEP.pyx":223
 *     Type            = PEPType
 *     ProblemType     = PEPProblemType
 *     Which           = PEPWhich             # <<<<<<<<<<<<<<
 *     Basis           = PEPBasis
 *     Scale           = PEPScale
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PEPWhich); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 223, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP->tp_dict, __pyx_n_s_Which, __pyx_t_2) < 0) __PYX_ERR(19, 223, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_PEP);

  /* "SLEPc/PEP.pyx":224
 *     ProblemType     = PEPProblemType
 *     Which           = PEPWhich
 *     Basis           = PEPBasis             # <<<<<<<<<<<<<<
 *     Scale           = PEPScale
 *     Refine          = PEPRefine
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PEPBasis); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 224, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP->tp_dict, __pyx_n_s_Basis, __pyx_t_2) < 0) __PYX_ERR(19, 224, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_PEP);

  /* "SLEPc/PEP.pyx":225
 *     Which           = PEPWhich
 *     Basis           = PEPBasis
 *     Scale           = PEPScale             # <<<<<<<<<<<<<<
 *     Refine          = PEPRefine
 *     RefineScheme    = PEPRefineScheme
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PEPScale); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 225, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP->tp_dict, __pyx_n_s_Scale, __pyx_t_2) < 0) __PYX_ERR(19, 225, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_PEP);

  /* "SLEPc/PEP.pyx":226
 *     Basis           = PEPBasis
 *     Scale           = PEPScale
 *     Refine          = PEPRefine             # <<<<<<<<<<<<<<
 *     RefineScheme    = PEPRefineScheme
 *     Extract         = PEPExtract
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PEPRefine); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 226, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP->tp_dict, __pyx_n_s_Refine, __pyx_t_2) < 0) __PYX_ERR(19, 226, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_PEP);

  /* "SLEPc/PEP.pyx":227
 *     Scale           = PEPScale
 *     Refine          = PEPRefine
 *     RefineScheme    = PEPRefineScheme             # <<<<<<<<<<<<<<
 *     Extract         = PEPExtract
 *     ErrorType       = PEPErrorType
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PEPRefineScheme); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 227, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP->tp_dict, __pyx_n_s_RefineScheme, __pyx_t_2) < 0) __PYX_ERR(19, 227, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_PEP);

  /* "SLEPc/PEP.pyx":228
 *     Refine          = PEPRefine
 *     RefineScheme    = PEPRefineScheme
 *     Extract         = PEPExtract             # <<<<<<<<<<<<<<
 *     ErrorType       = PEPErrorType
 *     Conv            = PEPConv
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PEPExtract); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 228, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP->tp_dict, __pyx_n_s_Extract, __pyx_t_2) < 0) __PYX_ERR(19, 228, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_PEP);

  /* "SLEPc/PEP.pyx":229
 *     RefineScheme    = PEPRefineScheme
 *     Extract         = PEPExtract
 *     ErrorType       = PEPErrorType             # <<<<<<<<<<<<<<
 *     Conv            = PEPConv
 *     Stop            = PEPStop
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PEPErrorType); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 229, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP->tp_dict, __pyx_n_s_ErrorType, __pyx_t_2) < 0) __PYX_ERR(19, 229, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_PEP);

  /* "SLEPc/PEP.pyx":230
 *     Extract         = PEPExtract
 *     ErrorType       = PEPErrorType
 *     Conv            = PEPConv             # <<<<<<<<<<<<<<
 *     Stop            = PEPStop
 *     ConvergedReason = PEPConvergedReason
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PEPConv); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 230, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP->tp_dict, __pyx_n_s_Conv, __pyx_t_2) < 0) __PYX_ERR(19, 230, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_PEP);

  /* "SLEPc/PEP.pyx":231
 *     ErrorType       = PEPErrorType
 *     Conv            = PEPConv
 *     Stop            = PEPStop             # <<<<<<<<<<<<<<
 *     ConvergedReason = PEPConvergedReason
 * 
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PEPStop); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 231, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP->tp_dict, __pyx_n_s_Stop, __pyx_t_2) < 0) __PYX_ERR(19, 231, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_PEP);

  /* "SLEPc/PEP.pyx":232
 *     Conv            = PEPConv
 *     Stop            = PEPStop
 *     ConvergedReason = PEPConvergedReason             # <<<<<<<<<<<<<<
 * 
 *     JDProjection    = PEPJDProjection
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PEPConvergedReason); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 232, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP->tp_dict, __pyx_n_s_ConvergedReason, __pyx_t_2) < 0) __PYX_ERR(19, 232, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_PEP);

  /* "SLEPc/PEP.pyx":234
 *     ConvergedReason = PEPConvergedReason
 * 
 *     JDProjection    = PEPJDProjection             # <<<<<<<<<<<<<<
 *     CISSExtraction  = PEPCISSExtraction
 * 
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PEPJDProjection); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 234, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP->tp_dict, __pyx_n_s_JDProjection, __pyx_t_2) < 0) __PYX_ERR(19, 234, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_PEP);

  /* "SLEPc/PEP.pyx":235
 * 
 *     JDProjection    = PEPJDProjection
 *     CISSExtraction  = PEPCISSExtraction             # <<<<<<<<<<<<<<
 * 
 *     def __cinit__(self):
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PEPCISSExtraction); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 235, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_PEP->tp_dict, __pyx_n_s_CISSExtraction, __pyx_t_2) < 0) __PYX_ERR(19, 235, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_PEP);

  /* "SLEPc/PEP.pyx":2017
 * # -----------------------------------------------------------------------------
 * 
 * del PEPType             # <<<<<<<<<<<<<<
 * del PEPProblemType
 * del PEPWhich
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_PEPType) < 0) __PYX_ERR(19, 2017, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":2018
 * 
 * del PEPType
 * del PEPProblemType             # <<<<<<<<<<<<<<
 * del PEPWhich
 * del PEPBasis
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_PEPProblemType) < 0) __PYX_ERR(19, 2018, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":2019
 * del PEPType
 * del PEPProblemType
 * del PEPWhich             # <<<<<<<<<<<<<<
 * del PEPBasis
 * del PEPScale
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_PEPWhich) < 0) __PYX_ERR(19, 2019, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":2020
 * del PEPProblemType
 * del PEPWhich
 * del PEPBasis             # <<<<<<<<<<<<<<
 * del PEPScale
 * del PEPRefine
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_PEPBasis) < 0) __PYX_ERR(19, 2020, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":2021
 * del PEPWhich
 * del PEPBasis
 * del PEPScale             # <<<<<<<<<<<<<<
 * del PEPRefine
 * del PEPRefineScheme
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_PEPScale) < 0) __PYX_ERR(19, 2021, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":2022
 * del PEPBasis
 * del PEPScale
 * del PEPRefine             # <<<<<<<<<<<<<<
 * del PEPRefineScheme
 * del PEPExtract
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_PEPRefine) < 0) __PYX_ERR(19, 2022, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":2023
 * del PEPScale
 * del PEPRefine
 * del PEPRefineScheme             # <<<<<<<<<<<<<<
 * del PEPExtract
 * del PEPErrorType
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_PEPRefineScheme) < 0) __PYX_ERR(19, 2023, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":2024
 * del PEPRefine
 * del PEPRefineScheme
 * del PEPExtract             # <<<<<<<<<<<<<<
 * del PEPErrorType
 * del PEPConv
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_PEPExtract) < 0) __PYX_ERR(19, 2024, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":2025
 * del PEPRefineScheme
 * del PEPExtract
 * del PEPErrorType             # <<<<<<<<<<<<<<
 * del PEPConv
 * del PEPStop
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_PEPErrorType) < 0) __PYX_ERR(19, 2025, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":2026
 * del PEPExtract
 * del PEPErrorType
 * del PEPConv             # <<<<<<<<<<<<<<
 * del PEPStop
 * del PEPConvergedReason
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_PEPConv) < 0) __PYX_ERR(19, 2026, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":2027
 * del PEPErrorType
 * del PEPConv
 * del PEPStop             # <<<<<<<<<<<<<<
 * del PEPConvergedReason
 * del PEPJDProjection
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_PEPStop) < 0) __PYX_ERR(19, 2027, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":2028
 * del PEPConv
 * del PEPStop
 * del PEPConvergedReason             # <<<<<<<<<<<<<<
 * del PEPJDProjection
 * del PEPCISSExtraction
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_PEPConvergedReason) < 0) __PYX_ERR(19, 2028, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":2029
 * del PEPStop
 * del PEPConvergedReason
 * del PEPJDProjection             # <<<<<<<<<<<<<<
 * del PEPCISSExtraction
 * 
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_PEPJDProjection) < 0) __PYX_ERR(19, 2029, __pyx_L1_error)

  /* "SLEPc/PEP.pyx":2030
 * del PEPConvergedReason
 * del PEPJDProjection
 * del PEPCISSExtraction             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_PEPCISSExtraction) < 0) __PYX_ERR(19, 2030, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class NEPType(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP type
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__58); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__58, __pyx_n_s_NEPType, __pyx_n_s_NEPType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_NEP_type_Nonlinear_eigensolvers); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/NEP.pyx":16
 *     - `NLEIGS`:   Fully rational Krylov method for nonlinear eigenproblems.
 *     """
 *     RII      = S_(NEPRII)             # <<<<<<<<<<<<<<
 *     SLP      = S_(NEPSLP)
 *     NARNOLDI = S_(NEPNARNOLDI)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(NEPRII); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 16, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RII, __pyx_t_4) < 0) __PYX_ERR(20, 16, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":17
 *     """
 *     RII      = S_(NEPRII)
 *     SLP      = S_(NEPSLP)             # <<<<<<<<<<<<<<
 *     NARNOLDI = S_(NEPNARNOLDI)
 *     CISS     = S_(NEPCISS)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(NEPSLP); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SLP, __pyx_t_4) < 0) __PYX_ERR(20, 17, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":18
 *     RII      = S_(NEPRII)
 *     SLP      = S_(NEPSLP)
 *     NARNOLDI = S_(NEPNARNOLDI)             # <<<<<<<<<<<<<<
 *     CISS     = S_(NEPCISS)
 *     INTERPOL = S_(NEPINTERPOL)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(NEPNARNOLDI); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NARNOLDI, __pyx_t_4) < 0) __PYX_ERR(20, 18, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":19
 *     SLP      = S_(NEPSLP)
 *     NARNOLDI = S_(NEPNARNOLDI)
 *     CISS     = S_(NEPCISS)             # <<<<<<<<<<<<<<
 *     INTERPOL = S_(NEPINTERPOL)
 *     NLEIGS   = S_(NEPNLEIGS)
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(NEPCISS); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 19, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CISS, __pyx_t_4) < 0) __PYX_ERR(20, 19, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":20
 *     NARNOLDI = S_(NEPNARNOLDI)
 *     CISS     = S_(NEPCISS)
 *     INTERPOL = S_(NEPINTERPOL)             # <<<<<<<<<<<<<<
 *     NLEIGS   = S_(NEPNLEIGS)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(NEPINTERPOL); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 20, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_INTERPOL, __pyx_t_4) < 0) __PYX_ERR(20, 20, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":21
 *     CISS     = S_(NEPCISS)
 *     INTERPOL = S_(NEPINTERPOL)
 *     NLEIGS   = S_(NEPNLEIGS)             # <<<<<<<<<<<<<<
 * 
 * class NEPProblemType(object):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(NEPNLEIGS); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 21, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NLEIGS, __pyx_t_4) < 0) __PYX_ERR(20, 21, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class NEPType(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP type
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_NEPType, __pyx_tuple__58, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_NEPType, __pyx_t_4) < 0) __PYX_ERR(20, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/NEP.pyx":23
 *     NLEIGS   = S_(NEPNLEIGS)
 * 
 * class NEPProblemType(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP problem type
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__59); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__59, __pyx_n_s_NEPProblemType, __pyx_n_s_NEPProblemType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_NEP_problem_type_GENERAL_Genera); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/NEP.pyx":30
 *     - `RATIONAL`: NEP defined in split form with all f_i rational.
 *     """
 *     GENERAL  = NEP_GENERAL             # <<<<<<<<<<<<<<
 *     RATIONAL = NEP_RATIONAL
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPProblemType(NEP_GENERAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 30, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_GENERAL, __pyx_t_4) < 0) __PYX_ERR(20, 30, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":31
 *     """
 *     GENERAL  = NEP_GENERAL
 *     RATIONAL = NEP_RATIONAL             # <<<<<<<<<<<<<<
 * 
 * class NEPErrorType(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPProblemType(NEP_RATIONAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 31, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RATIONAL, __pyx_t_4) < 0) __PYX_ERR(20, 31, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":23
 *     NLEIGS   = S_(NEPNLEIGS)
 * 
 * class NEPProblemType(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP problem type
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_NEPProblemType, __pyx_tuple__59, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 23, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_NEPProblemType, __pyx_t_4) < 0) __PYX_ERR(20, 23, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/NEP.pyx":33
 *     RATIONAL = NEP_RATIONAL
 * 
 * class NEPErrorType(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP error type to assess accuracy of computed solutions
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__60); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 33, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__60, __pyx_n_s_NEPErrorType, __pyx_n_s_NEPErrorType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_NEP_error_type_to_assess_accura); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 33, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/NEP.pyx":41
 *     - `BACKWARD`: Backward error.
 *     """
 *     ABSOLUTE = NEP_ERROR_ABSOLUTE             # <<<<<<<<<<<<<<
 *     RELATIVE = NEP_ERROR_RELATIVE
 *     BACKWARD = NEP_ERROR_BACKWARD
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPErrorType(NEP_ERROR_ABSOLUTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 41, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ABSOLUTE, __pyx_t_4) < 0) __PYX_ERR(20, 41, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":42
 *     """
 *     ABSOLUTE = NEP_ERROR_ABSOLUTE
 *     RELATIVE = NEP_ERROR_RELATIVE             # <<<<<<<<<<<<<<
 *     BACKWARD = NEP_ERROR_BACKWARD
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPErrorType(NEP_ERROR_RELATIVE); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 42, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RELATIVE, __pyx_t_4) < 0) __PYX_ERR(20, 42, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":43
 *     ABSOLUTE = NEP_ERROR_ABSOLUTE
 *     RELATIVE = NEP_ERROR_RELATIVE
 *     BACKWARD = NEP_ERROR_BACKWARD             # <<<<<<<<<<<<<<
 * 
 * class NEPWhich(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPErrorType(NEP_ERROR_BACKWARD); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 43, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_BACKWARD, __pyx_t_4) < 0) __PYX_ERR(20, 43, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":33
 *     RATIONAL = NEP_RATIONAL
 * 
 * class NEPErrorType(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP error type to assess accuracy of computed solutions
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_NEPErrorType, __pyx_tuple__60, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 33, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_NEPErrorType, __pyx_t_4) < 0) __PYX_ERR(20, 33, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/NEP.pyx":45
 *     BACKWARD = NEP_ERROR_BACKWARD
 * 
 * class NEPWhich(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP desired part of spectrum
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__61); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 45, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__61, __pyx_n_s_NEPWhich, __pyx_n_s_NEPWhich, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_NEP_desired_part_of_spectrum_LA); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 45, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/NEP.pyx":61
 *     - `USER`:               User defined selection.
 *     """
 *     LARGEST_MAGNITUDE  = NEP_LARGEST_MAGNITUDE             # <<<<<<<<<<<<<<
 *     SMALLEST_MAGNITUDE = NEP_SMALLEST_MAGNITUDE
 *     LARGEST_REAL       = NEP_LARGEST_REAL
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPWhich(NEP_LARGEST_MAGNITUDE); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 61, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LARGEST_MAGNITUDE, __pyx_t_4) < 0) __PYX_ERR(20, 61, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":62
 *     """
 *     LARGEST_MAGNITUDE  = NEP_LARGEST_MAGNITUDE
 *     SMALLEST_MAGNITUDE = NEP_SMALLEST_MAGNITUDE             # <<<<<<<<<<<<<<
 *     LARGEST_REAL       = NEP_LARGEST_REAL
 *     SMALLEST_REAL      = NEP_SMALLEST_REAL
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPWhich(NEP_SMALLEST_MAGNITUDE); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 62, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SMALLEST_MAGNITUDE, __pyx_t_4) < 0) __PYX_ERR(20, 62, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":63
 *     LARGEST_MAGNITUDE  = NEP_LARGEST_MAGNITUDE
 *     SMALLEST_MAGNITUDE = NEP_SMALLEST_MAGNITUDE
 *     LARGEST_REAL       = NEP_LARGEST_REAL             # <<<<<<<<<<<<<<
 *     SMALLEST_REAL      = NEP_SMALLEST_REAL
 *     LARGEST_IMAGINARY  = NEP_LARGEST_IMAGINARY
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPWhich(NEP_LARGEST_REAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 63, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LARGEST_REAL, __pyx_t_4) < 0) __PYX_ERR(20, 63, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":64
 *     SMALLEST_MAGNITUDE = NEP_SMALLEST_MAGNITUDE
 *     LARGEST_REAL       = NEP_LARGEST_REAL
 *     SMALLEST_REAL      = NEP_SMALLEST_REAL             # <<<<<<<<<<<<<<
 *     LARGEST_IMAGINARY  = NEP_LARGEST_IMAGINARY
 *     SMALLEST_IMAGINARY = NEP_SMALLEST_IMAGINARY
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPWhich(NEP_SMALLEST_REAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 64, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SMALLEST_REAL, __pyx_t_4) < 0) __PYX_ERR(20, 64, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":65
 *     LARGEST_REAL       = NEP_LARGEST_REAL
 *     SMALLEST_REAL      = NEP_SMALLEST_REAL
 *     LARGEST_IMAGINARY  = NEP_LARGEST_IMAGINARY             # <<<<<<<<<<<<<<
 *     SMALLEST_IMAGINARY = NEP_SMALLEST_IMAGINARY
 *     TARGET_MAGNITUDE   = NEP_TARGET_MAGNITUDE
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPWhich(NEP_LARGEST_IMAGINARY); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 65, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_LARGEST_IMAGINARY, __pyx_t_4) < 0) __PYX_ERR(20, 65, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":66
 *     SMALLEST_REAL      = NEP_SMALLEST_REAL
 *     LARGEST_IMAGINARY  = NEP_LARGEST_IMAGINARY
 *     SMALLEST_IMAGINARY = NEP_SMALLEST_IMAGINARY             # <<<<<<<<<<<<<<
 *     TARGET_MAGNITUDE   = NEP_TARGET_MAGNITUDE
 *     TARGET_REAL        = NEP_TARGET_REAL
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPWhich(NEP_SMALLEST_IMAGINARY); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 66, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SMALLEST_IMAGINARY, __pyx_t_4) < 0) __PYX_ERR(20, 66, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":67
 *     LARGEST_IMAGINARY  = NEP_LARGEST_IMAGINARY
 *     SMALLEST_IMAGINARY = NEP_SMALLEST_IMAGINARY
 *     TARGET_MAGNITUDE   = NEP_TARGET_MAGNITUDE             # <<<<<<<<<<<<<<
 *     TARGET_REAL        = NEP_TARGET_REAL
 *     TARGET_IMAGINARY   = NEP_TARGET_IMAGINARY
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPWhich(NEP_TARGET_MAGNITUDE); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 67, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TARGET_MAGNITUDE, __pyx_t_4) < 0) __PYX_ERR(20, 67, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":68
 *     SMALLEST_IMAGINARY = NEP_SMALLEST_IMAGINARY
 *     TARGET_MAGNITUDE   = NEP_TARGET_MAGNITUDE
 *     TARGET_REAL        = NEP_TARGET_REAL             # <<<<<<<<<<<<<<
 *     TARGET_IMAGINARY   = NEP_TARGET_IMAGINARY
 *     ALL                = NEP_ALL
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPWhich(NEP_TARGET_REAL); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 68, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TARGET_REAL, __pyx_t_4) < 0) __PYX_ERR(20, 68, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":69
 *     TARGET_MAGNITUDE   = NEP_TARGET_MAGNITUDE
 *     TARGET_REAL        = NEP_TARGET_REAL
 *     TARGET_IMAGINARY   = NEP_TARGET_IMAGINARY             # <<<<<<<<<<<<<<
 *     ALL                = NEP_ALL
 *     USER               = NEP_WHICH_USER
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPWhich(NEP_TARGET_IMAGINARY); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 69, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_TARGET_IMAGINARY, __pyx_t_4) < 0) __PYX_ERR(20, 69, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":70
 *     TARGET_REAL        = NEP_TARGET_REAL
 *     TARGET_IMAGINARY   = NEP_TARGET_IMAGINARY
 *     ALL                = NEP_ALL             # <<<<<<<<<<<<<<
 *     USER               = NEP_WHICH_USER
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPWhich(NEP_ALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 70, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ALL, __pyx_t_4) < 0) __PYX_ERR(20, 70, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":71
 *     TARGET_IMAGINARY   = NEP_TARGET_IMAGINARY
 *     ALL                = NEP_ALL
 *     USER               = NEP_WHICH_USER             # <<<<<<<<<<<<<<
 * 
 * class NEPConvergedReason(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPWhich(NEP_WHICH_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 71, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_USER, __pyx_t_4) < 0) __PYX_ERR(20, 71, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":45
 *     BACKWARD = NEP_ERROR_BACKWARD
 * 
 * class NEPWhich(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP desired part of spectrum
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_NEPWhich, __pyx_tuple__61, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 45, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_NEPWhich, __pyx_t_4) < 0) __PYX_ERR(20, 45, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/NEP.pyx":73
 *     USER               = NEP_WHICH_USER
 * 
 * class NEPConvergedReason(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP convergence reasons
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__62); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__62, __pyx_n_s_NEPConvergedReason, __pyx_n_s_NEPConvergedReason, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_NEP_convergence_reasons_CONVERG); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/NEP.pyx":85
 *     - `CONVERGED_ITERATING`:         Iteration not finished yet.
 *     """
 *     CONVERGED_TOL               = NEP_CONVERGED_TOL             # <<<<<<<<<<<<<<
 *     CONVERGED_USER              = NEP_CONVERGED_USER
 *     DIVERGED_ITS                = NEP_DIVERGED_ITS
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPConvergedReason(NEP_CONVERGED_TOL); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 85, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_TOL, __pyx_t_4) < 0) __PYX_ERR(20, 85, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":86
 *     """
 *     CONVERGED_TOL               = NEP_CONVERGED_TOL
 *     CONVERGED_USER              = NEP_CONVERGED_USER             # <<<<<<<<<<<<<<
 *     DIVERGED_ITS                = NEP_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN          = NEP_DIVERGED_BREAKDOWN
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPConvergedReason(NEP_CONVERGED_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 86, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_USER, __pyx_t_4) < 0) __PYX_ERR(20, 86, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":87
 *     CONVERGED_TOL               = NEP_CONVERGED_TOL
 *     CONVERGED_USER              = NEP_CONVERGED_USER
 *     DIVERGED_ITS                = NEP_DIVERGED_ITS             # <<<<<<<<<<<<<<
 *     DIVERGED_BREAKDOWN          = NEP_DIVERGED_BREAKDOWN
 *     DIVERGED_LINEAR_SOLVE       = NEP_DIVERGED_LINEAR_SOLVE
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPConvergedReason(NEP_DIVERGED_ITS); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 87, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVERGED_ITS, __pyx_t_4) < 0) __PYX_ERR(20, 87, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":88
 *     CONVERGED_USER              = NEP_CONVERGED_USER
 *     DIVERGED_ITS                = NEP_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN          = NEP_DIVERGED_BREAKDOWN             # <<<<<<<<<<<<<<
 *     DIVERGED_LINEAR_SOLVE       = NEP_DIVERGED_LINEAR_SOLVE
 *     DIVERGED_SUBSPACE_EXHAUSTED = NEP_DIVERGED_SUBSPACE_EXHAUSTED
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPConvergedReason(NEP_DIVERGED_BREAKDOWN); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 88, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVERGED_BREAKDOWN, __pyx_t_4) < 0) __PYX_ERR(20, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":89
 *     DIVERGED_ITS                = NEP_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN          = NEP_DIVERGED_BREAKDOWN
 *     DIVERGED_LINEAR_SOLVE       = NEP_DIVERGED_LINEAR_SOLVE             # <<<<<<<<<<<<<<
 *     DIVERGED_SUBSPACE_EXHAUSTED = NEP_DIVERGED_SUBSPACE_EXHAUSTED
 *     CONVERGED_ITERATING         = NEP_CONVERGED_ITERATING
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPConvergedReason(NEP_DIVERGED_LINEAR_SOLVE); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 89, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVERGED_LINEAR_SOLVE, __pyx_t_4) < 0) __PYX_ERR(20, 89, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":90
 *     DIVERGED_BREAKDOWN          = NEP_DIVERGED_BREAKDOWN
 *     DIVERGED_LINEAR_SOLVE       = NEP_DIVERGED_LINEAR_SOLVE
 *     DIVERGED_SUBSPACE_EXHAUSTED = NEP_DIVERGED_SUBSPACE_EXHAUSTED             # <<<<<<<<<<<<<<
 *     CONVERGED_ITERATING         = NEP_CONVERGED_ITERATING
 *     ITERATING                   = NEP_CONVERGED_ITERATING
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPConvergedReason(NEP_DIVERGED_SUBSPACE_EXHAUSTED); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 90, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVERGED_SUBSPACE_EXHAUSTED, __pyx_t_4) < 0) __PYX_ERR(20, 90, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":91
 *     DIVERGED_LINEAR_SOLVE       = NEP_DIVERGED_LINEAR_SOLVE
 *     DIVERGED_SUBSPACE_EXHAUSTED = NEP_DIVERGED_SUBSPACE_EXHAUSTED
 *     CONVERGED_ITERATING         = NEP_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *     ITERATING                   = NEP_CONVERGED_ITERATING
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPConvergedReason(NEP_CONVERGED_ITERATING); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 91, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_ITERATING, __pyx_t_4) < 0) __PYX_ERR(20, 91, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":92
 *     DIVERGED_SUBSPACE_EXHAUSTED = NEP_DIVERGED_SUBSPACE_EXHAUSTED
 *     CONVERGED_ITERATING         = NEP_CONVERGED_ITERATING
 *     ITERATING                   = NEP_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 * 
 * class NEPRefine(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPConvergedReason(NEP_CONVERGED_ITERATING); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 92, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ITERATING, __pyx_t_4) < 0) __PYX_ERR(20, 92, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":73
 *     USER               = NEP_WHICH_USER
 * 
 * class NEPConvergedReason(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP convergence reasons
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_NEPConvergedReason, __pyx_tuple__62, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 73, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_NEPConvergedReason, __pyx_t_4) < 0) __PYX_ERR(20, 73, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/NEP.pyx":94
 *     ITERATING                   = NEP_CONVERGED_ITERATING
 * 
 * class NEPRefine(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP refinement strategy
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__63); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 94, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__63, __pyx_n_s_NEPRefine, __pyx_n_s_NEPRefine, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_NEP_refinement_strategy_NONE_No); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 94, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/NEP.pyx":102
 *     - `MULTIPLE`: Refine all eigenpairs simultaneously (invariant pair).
 *     """
 *     NONE     = NEP_REFINE_NONE             # <<<<<<<<<<<<<<
 *     SIMPLE   = NEP_REFINE_SIMPLE
 *     MULTIPLE = NEP_REFINE_MULTIPLE
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPRefine(NEP_REFINE_NONE); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 102, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NONE, __pyx_t_4) < 0) __PYX_ERR(20, 102, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":103
 *     """
 *     NONE     = NEP_REFINE_NONE
 *     SIMPLE   = NEP_REFINE_SIMPLE             # <<<<<<<<<<<<<<
 *     MULTIPLE = NEP_REFINE_MULTIPLE
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPRefine(NEP_REFINE_SIMPLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 103, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SIMPLE, __pyx_t_4) < 0) __PYX_ERR(20, 103, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":104
 *     NONE     = NEP_REFINE_NONE
 *     SIMPLE   = NEP_REFINE_SIMPLE
 *     MULTIPLE = NEP_REFINE_MULTIPLE             # <<<<<<<<<<<<<<
 * 
 * class NEPRefineScheme(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPRefine(NEP_REFINE_MULTIPLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 104, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_MULTIPLE, __pyx_t_4) < 0) __PYX_ERR(20, 104, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":94
 *     ITERATING                   = NEP_CONVERGED_ITERATING
 * 
 * class NEPRefine(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP refinement strategy
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_NEPRefine, __pyx_tuple__63, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 94, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_NEPRefine, __pyx_t_4) < 0) __PYX_ERR(20, 94, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/NEP.pyx":106
 *     MULTIPLE = NEP_REFINE_MULTIPLE
 * 
 * class NEPRefineScheme(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP scheme for solving linear systems during iterative refinement
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__64); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 106, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__64, __pyx_n_s_NEPRefineScheme, __pyx_n_s_NEPRefineScheme, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_NEP_scheme_for_solving_linear_s); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 106, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/NEP.pyx":114
 *     - `EXPLICIT`: Build the explicit matrix.
 *     """
 *     SCHUR    = NEP_REFINE_SCHEME_SCHUR             # <<<<<<<<<<<<<<
 *     MBE      = NEP_REFINE_SCHEME_MBE
 *     EXPLICIT = NEP_REFINE_SCHEME_EXPLICIT
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPRefineScheme(NEP_REFINE_SCHEME_SCHUR); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 114, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_SCHUR, __pyx_t_4) < 0) __PYX_ERR(20, 114, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":115
 *     """
 *     SCHUR    = NEP_REFINE_SCHEME_SCHUR
 *     MBE      = NEP_REFINE_SCHEME_MBE             # <<<<<<<<<<<<<<
 *     EXPLICIT = NEP_REFINE_SCHEME_EXPLICIT
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPRefineScheme(NEP_REFINE_SCHEME_MBE); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 115, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_MBE, __pyx_t_4) < 0) __PYX_ERR(20, 115, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":116
 *     SCHUR    = NEP_REFINE_SCHEME_SCHUR
 *     MBE      = NEP_REFINE_SCHEME_MBE
 *     EXPLICIT = NEP_REFINE_SCHEME_EXPLICIT             # <<<<<<<<<<<<<<
 * 
 * class NEPConv(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPRefineScheme(NEP_REFINE_SCHEME_EXPLICIT); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 116, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_EXPLICIT, __pyx_t_4) < 0) __PYX_ERR(20, 116, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":106
 *     MULTIPLE = NEP_REFINE_MULTIPLE
 * 
 * class NEPRefineScheme(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP scheme for solving linear systems during iterative refinement
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_NEPRefineScheme, __pyx_tuple__64, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 106, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_NEPRefineScheme, __pyx_t_4) < 0) __PYX_ERR(20, 106, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/NEP.pyx":118
 *     EXPLICIT = NEP_REFINE_SCHEME_EXPLICIT
 * 
 * class NEPConv(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP convergence test
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__65); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 118, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__65, __pyx_n_s_NEPConv, __pyx_n_s_NEPConv, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_NEP_convergence_test_ABS_Absolu); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 118, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/NEP.pyx":127
 *     - `USER`: User-defined convergence test.
 *     """
 *     ABS  = NEP_CONV_ABS             # <<<<<<<<<<<<<<
 *     REL  = NEP_CONV_REL
 *     NORM = NEP_CONV_NORM
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPConv(NEP_CONV_ABS); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 127, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ABS, __pyx_t_4) < 0) __PYX_ERR(20, 127, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":128
 *     """
 *     ABS  = NEP_CONV_ABS
 *     REL  = NEP_CONV_REL             # <<<<<<<<<<<<<<
 *     NORM = NEP_CONV_NORM
 *     USER = NEP_CONV_USER
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPConv(NEP_CONV_REL); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 128, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_REL, __pyx_t_4) < 0) __PYX_ERR(20, 128, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":129
 *     ABS  = NEP_CONV_ABS
 *     REL  = NEP_CONV_REL
 *     NORM = NEP_CONV_NORM             # <<<<<<<<<<<<<<
 *     USER = NEP_CONV_USER
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPConv(NEP_CONV_NORM); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 129, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_NORM, __pyx_t_4) < 0) __PYX_ERR(20, 129, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":130
 *     REL  = NEP_CONV_REL
 *     NORM = NEP_CONV_NORM
 *     USER = NEP_CONV_USER             # <<<<<<<<<<<<<<
 * 
 * class NEPStop(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPConv(NEP_CONV_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 130, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_USER, __pyx_t_4) < 0) __PYX_ERR(20, 130, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":118
 *     EXPLICIT = NEP_REFINE_SCHEME_EXPLICIT
 * 
 * class NEPConv(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP convergence test
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_NEPConv, __pyx_tuple__65, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 118, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_NEPConv, __pyx_t_4) < 0) __PYX_ERR(20, 118, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/NEP.pyx":132
 *     USER = NEP_CONV_USER
 * 
 * class NEPStop(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP stopping test
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__66); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 132, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__66, __pyx_n_s_NEPStop, __pyx_n_s_NEPStop, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_NEP_stopping_test_BASIC_Default); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 132, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/NEP.pyx":139
 *     - `USER`:  User-defined stopping test.
 *     """
 *     BASIC = NEP_STOP_BASIC             # <<<<<<<<<<<<<<
 *     USER  = NEP_STOP_USER
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPStop(NEP_STOP_BASIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 139, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_BASIC, __pyx_t_4) < 0) __PYX_ERR(20, 139, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":140
 *     """
 *     BASIC = NEP_STOP_BASIC
 *     USER  = NEP_STOP_USER             # <<<<<<<<<<<<<<
 * 
 * class NEPCISSExtraction(object):
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPStop(NEP_STOP_USER); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 140, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_USER, __pyx_t_4) < 0) __PYX_ERR(20, 140, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":132
 *     USER = NEP_CONV_USER
 * 
 * class NEPStop(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP stopping test
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_NEPStop, __pyx_tuple__66, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 132, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_NEPStop, __pyx_t_4) < 0) __PYX_ERR(20, 132, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/NEP.pyx":142
 *     USER  = NEP_STOP_USER
 * 
 * class NEPCISSExtraction(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP CISS extraction technique
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__67); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__67, __pyx_n_s_NEPCISSExtraction, __pyx_n_s_NEPCISSExtraction, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_NEP_CISS_extraction_technique_R); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/NEP.pyx":150
 *     - `CAA`:    Communication-avoiding Arnoldi.
 *     """
 *     RITZ   = NEP_CISS_EXTRACTION_RITZ             # <<<<<<<<<<<<<<
 *     HANKEL = NEP_CISS_EXTRACTION_HANKEL
 *     CAA    = NEP_CISS_EXTRACTION_CAA
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPCISSExtraction(NEP_CISS_EXTRACTION_RITZ); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 150, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_RITZ, __pyx_t_4) < 0) __PYX_ERR(20, 150, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":151
 *     """
 *     RITZ   = NEP_CISS_EXTRACTION_RITZ
 *     HANKEL = NEP_CISS_EXTRACTION_HANKEL             # <<<<<<<<<<<<<<
 *     CAA    = NEP_CISS_EXTRACTION_CAA
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPCISSExtraction(NEP_CISS_EXTRACTION_HANKEL); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 151, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_HANKEL, __pyx_t_4) < 0) __PYX_ERR(20, 151, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":152
 *     RITZ   = NEP_CISS_EXTRACTION_RITZ
 *     HANKEL = NEP_CISS_EXTRACTION_HANKEL
 *     CAA    = NEP_CISS_EXTRACTION_CAA             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_4 = __Pyx_PyInt_From_NEPCISSExtraction(NEP_CISS_EXTRACTION_CAA); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 152, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CAA, __pyx_t_4) < 0) __PYX_ERR(20, 152, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/NEP.pyx":142
 *     USER  = NEP_STOP_USER
 * 
 * class NEPCISSExtraction(object):             # <<<<<<<<<<<<<<
 *     """
 *     NEP CISS extraction technique
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_NEPCISSExtraction, __pyx_tuple__67, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(20, 142, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_NEPCISSExtraction, __pyx_t_4) < 0) __PYX_ERR(20, 142, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/NEP.pyx":162
 *     """
 * 
 *     Type            = NEPType             # <<<<<<<<<<<<<<
 *     ProblemType     = NEPProblemType
 *     ErrorType       = NEPErrorType
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NEPType); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 162, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_NEP->tp_dict, __pyx_n_s_Type, __pyx_t_2) < 0) __PYX_ERR(20, 162, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_NEP);

  /* "SLEPc/NEP.pyx":163
 * 
 *     Type            = NEPType
 *     ProblemType     = NEPProblemType             # <<<<<<<<<<<<<<
 *     ErrorType       = NEPErrorType
 *     Which           = NEPWhich
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NEPProblemType); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 163, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_NEP->tp_dict, __pyx_n_s_ProblemType, __pyx_t_2) < 0) __PYX_ERR(20, 163, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_NEP);

  /* "SLEPc/NEP.pyx":164
 *     Type            = NEPType
 *     ProblemType     = NEPProblemType
 *     ErrorType       = NEPErrorType             # <<<<<<<<<<<<<<
 *     Which           = NEPWhich
 *     ConvergedReason = NEPConvergedReason
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NEPErrorType); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 164, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_NEP->tp_dict, __pyx_n_s_ErrorType, __pyx_t_2) < 0) __PYX_ERR(20, 164, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_NEP);

  /* "SLEPc/NEP.pyx":165
 *     ProblemType     = NEPProblemType
 *     ErrorType       = NEPErrorType
 *     Which           = NEPWhich             # <<<<<<<<<<<<<<
 *     ConvergedReason = NEPConvergedReason
 *     Refine          = NEPRefine
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NEPWhich); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 165, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_NEP->tp_dict, __pyx_n_s_Which, __pyx_t_2) < 0) __PYX_ERR(20, 165, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_NEP);

  /* "SLEPc/NEP.pyx":166
 *     ErrorType       = NEPErrorType
 *     Which           = NEPWhich
 *     ConvergedReason = NEPConvergedReason             # <<<<<<<<<<<<<<
 *     Refine          = NEPRefine
 *     RefineScheme    = NEPRefineScheme
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NEPConvergedReason); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 166, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_NEP->tp_dict, __pyx_n_s_ConvergedReason, __pyx_t_2) < 0) __PYX_ERR(20, 166, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_NEP);

  /* "SLEPc/NEP.pyx":167
 *     Which           = NEPWhich
 *     ConvergedReason = NEPConvergedReason
 *     Refine          = NEPRefine             # <<<<<<<<<<<<<<
 *     RefineScheme    = NEPRefineScheme
 *     Conv            = NEPConv
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NEPRefine); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 167, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_NEP->tp_dict, __pyx_n_s_Refine, __pyx_t_2) < 0) __PYX_ERR(20, 167, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_NEP);

  /* "SLEPc/NEP.pyx":168
 *     ConvergedReason = NEPConvergedReason
 *     Refine          = NEPRefine
 *     RefineScheme    = NEPRefineScheme             # <<<<<<<<<<<<<<
 *     Conv            = NEPConv
 *     Stop            = NEPStop
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NEPRefineScheme); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 168, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_NEP->tp_dict, __pyx_n_s_RefineScheme, __pyx_t_2) < 0) __PYX_ERR(20, 168, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_NEP);

  /* "SLEPc/NEP.pyx":169
 *     Refine          = NEPRefine
 *     RefineScheme    = NEPRefineScheme
 *     Conv            = NEPConv             # <<<<<<<<<<<<<<
 *     Stop            = NEPStop
 * 
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NEPConv); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 169, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_NEP->tp_dict, __pyx_n_s_Conv, __pyx_t_2) < 0) __PYX_ERR(20, 169, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_NEP);

  /* "SLEPc/NEP.pyx":170
 *     RefineScheme    = NEPRefineScheme
 *     Conv            = NEPConv
 *     Stop            = NEPStop             # <<<<<<<<<<<<<<
 * 
 *     CISSExtraction  = NEPCISSExtraction
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NEPStop); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 170, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_NEP->tp_dict, __pyx_n_s_Stop, __pyx_t_2) < 0) __PYX_ERR(20, 170, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_NEP);

  /* "SLEPc/NEP.pyx":172
 *     Stop            = NEPStop
 * 
 *     CISSExtraction  = NEPCISSExtraction             # <<<<<<<<<<<<<<
 * 
 *     def __cinit__(self):
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NEPCISSExtraction); if (unlikely(!__pyx_t_2)) __PYX_ERR(20, 172, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_NEP->tp_dict, __pyx_n_s_CISSExtraction, __pyx_t_2) < 0) __PYX_ERR(20, 172, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_NEP);

  /* "SLEPc/NEP.pyx":2000
 * # -----------------------------------------------------------------------------
 * 
 * del NEPType             # <<<<<<<<<<<<<<
 * del NEPProblemType
 * del NEPErrorType
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_NEPType) < 0) __PYX_ERR(20, 2000, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":2001
 * 
 * del NEPType
 * del NEPProblemType             # <<<<<<<<<<<<<<
 * del NEPErrorType
 * del NEPWhich
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_NEPProblemType) < 0) __PYX_ERR(20, 2001, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":2002
 * del NEPType
 * del NEPProblemType
 * del NEPErrorType             # <<<<<<<<<<<<<<
 * del NEPWhich
 * del NEPConvergedReason
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_NEPErrorType) < 0) __PYX_ERR(20, 2002, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":2003
 * del NEPProblemType
 * del NEPErrorType
 * del NEPWhich             # <<<<<<<<<<<<<<
 * del NEPConvergedReason
 * del NEPRefine
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_NEPWhich) < 0) __PYX_ERR(20, 2003, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":2004
 * del NEPErrorType
 * del NEPWhich
 * del NEPConvergedReason             # <<<<<<<<<<<<<<
 * del NEPRefine
 * del NEPRefineScheme
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_NEPConvergedReason) < 0) __PYX_ERR(20, 2004, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":2005
 * del NEPWhich
 * del NEPConvergedReason
 * del NEPRefine             # <<<<<<<<<<<<<<
 * del NEPRefineScheme
 * del NEPConv
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_NEPRefine) < 0) __PYX_ERR(20, 2005, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":2006
 * del NEPConvergedReason
 * del NEPRefine
 * del NEPRefineScheme             # <<<<<<<<<<<<<<
 * del NEPConv
 * del NEPStop
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_NEPRefineScheme) < 0) __PYX_ERR(20, 2006, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":2007
 * del NEPRefine
 * del NEPRefineScheme
 * del NEPConv             # <<<<<<<<<<<<<<
 * del NEPStop
 * del NEPCISSExtraction
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_NEPConv) < 0) __PYX_ERR(20, 2007, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":2008
 * del NEPRefineScheme
 * del NEPConv
 * del NEPStop             # <<<<<<<<<<<<<<
 * del NEPCISSExtraction
 * 
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_NEPStop) < 0) __PYX_ERR(20, 2008, __pyx_L1_error)

  /* "SLEPc/NEP.pyx":2009
 * del NEPConv
 * del NEPStop
 * del NEPCISSExtraction             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_NEPCISSExtraction) < 0) __PYX_ERR(20, 2009, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class MFNType(object):             # <<<<<<<<<<<<<<
 *     """
 *     MFN type
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__68); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__68, __pyx_n_s_MFNType, __pyx_n_s_MFNType, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, __pyx_kp_s_MFN_type_Action_of_a_matrix_fun); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/MFN.pyx":12
 *     - `EXPOKIT`: Implementation of the method in Expokit.
 *     """
 *     KRYLOV   = S_(MFNKRYLOV)             # <<<<<<<<<<<<<<
 *     EXPOKIT  = S_(MFNEXPOKIT)
 * 
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(MFNKRYLOV); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 12, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_KRYLOV, __pyx_t_4) < 0) __PYX_ERR(21, 12, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/MFN.pyx":13
 *     """
 *     KRYLOV   = S_(MFNKRYLOV)
 *     EXPOKIT  = S_(MFNEXPOKIT)             # <<<<<<<<<<<<<<
 * 
 * class MFNConvergedReason(object):
 */
  __pyx_t_4 = __pyx_f_8slepc4py_5SLEPc_S_(MFNEXPOKIT); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_EXPOKIT, __pyx_t_4) < 0) __PYX_ERR(21, 13, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/MFN.pyx":3
 * # -----------------------------------------------------------------------------
 * 
 * class MFNType(object):             # <<<<<<<<<<<<<<
 *     """
 *     MFN type
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_MFNType, __pyx_tuple__68, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MFNType, __pyx_t_4) < 0) __PYX_ERR(21, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/MFN.pyx":15
 *     EXPOKIT  = S_(MFNEXPOKIT)
 * 
 * class MFNConvergedReason(object):             # <<<<<<<<<<<<<<
 *     CONVERGED_TOL       = MFN_CONVERGED_TOL
 *     CONVERGED_ITS       = MFN_CONVERGED_ITS
 */
  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__69); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__69, __pyx_n_s_MFNConvergedReason, __pyx_n_s_MFNConvergedReason, (PyObject *) NULL, __pyx_n_s_slepc4py_SLEPc, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);

  /* "SLEPc/MFN.pyx":16
 * 
 * class MFNConvergedReason(object):
 *     CONVERGED_TOL       = MFN_CONVERGED_TOL             # <<<<<<<<<<<<<<
 *     CONVERGED_ITS       = MFN_CONVERGED_ITS
 *     DIVERGED_ITS        = MFN_DIVERGED_ITS
 */
  __pyx_t_4 = __Pyx_PyInt_From_MFNConvergedReason(MFN_CONVERGED_TOL); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 16, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_TOL, __pyx_t_4) < 0) __PYX_ERR(21, 16, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/MFN.pyx":17
 * class MFNConvergedReason(object):
 *     CONVERGED_TOL       = MFN_CONVERGED_TOL
 *     CONVERGED_ITS       = MFN_CONVERGED_ITS             # <<<<<<<<<<<<<<
 *     DIVERGED_ITS        = MFN_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN  = MFN_DIVERGED_BREAKDOWN
 */
  __pyx_t_4 = __Pyx_PyInt_From_MFNConvergedReason(MFN_CONVERGED_ITS); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 17, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_ITS, __pyx_t_4) < 0) __PYX_ERR(21, 17, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/MFN.pyx":18
 *     CONVERGED_TOL       = MFN_CONVERGED_TOL
 *     CONVERGED_ITS       = MFN_CONVERGED_ITS
 *     DIVERGED_ITS        = MFN_DIVERGED_ITS             # <<<<<<<<<<<<<<
 *     DIVERGED_BREAKDOWN  = MFN_DIVERGED_BREAKDOWN
 *     CONVERGED_ITERATING = MFN_CONVERGED_ITERATING
 */
  __pyx_t_4 = __Pyx_PyInt_From_MFNConvergedReason(MFN_DIVERGED_ITS); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 18, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVERGED_ITS, __pyx_t_4) < 0) __PYX_ERR(21, 18, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/MFN.pyx":19
 *     CONVERGED_ITS       = MFN_CONVERGED_ITS
 *     DIVERGED_ITS        = MFN_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN  = MFN_DIVERGED_BREAKDOWN             # <<<<<<<<<<<<<<
 *     CONVERGED_ITERATING = MFN_CONVERGED_ITERATING
 *     ITERATING           = MFN_CONVERGED_ITERATING
 */
  __pyx_t_4 = __Pyx_PyInt_From_MFNConvergedReason(MFN_DIVERGED_BREAKDOWN); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 19, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_DIVERGED_BREAKDOWN, __pyx_t_4) < 0) __PYX_ERR(21, 19, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/MFN.pyx":20
 *     DIVERGED_ITS        = MFN_DIVERGED_ITS
 *     DIVERGED_BREAKDOWN  = MFN_DIVERGED_BREAKDOWN
 *     CONVERGED_ITERATING = MFN_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 *     ITERATING           = MFN_CONVERGED_ITERATING
 * 
 */
  __pyx_t_4 = __Pyx_PyInt_From_MFNConvergedReason(MFN_CONVERGED_ITERATING); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 20, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_CONVERGED_ITERATING, __pyx_t_4) < 0) __PYX_ERR(21, 20, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/MFN.pyx":21
 *     DIVERGED_BREAKDOWN  = MFN_DIVERGED_BREAKDOWN
 *     CONVERGED_ITERATING = MFN_CONVERGED_ITERATING
 *     ITERATING           = MFN_CONVERGED_ITERATING             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  __pyx_t_4 = __Pyx_PyInt_From_MFNConvergedReason(MFN_CONVERGED_ITERATING); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 21, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_ITERATING, __pyx_t_4) < 0) __PYX_ERR(21, 21, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  /* "SLEPc/MFN.pyx":15
 *     EXPOKIT  = S_(MFNEXPOKIT)
 * 
 * class MFNConvergedReason(object):             # <<<<<<<<<<<<<<
 *     CONVERGED_TOL       = MFN_CONVERGED_TOL
 *     CONVERGED_ITS       = MFN_CONVERGED_ITS
 */
  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_MFNConvergedReason, __pyx_tuple__69, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 15, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MFNConvergedReason, __pyx_t_4) < 0) __PYX_ERR(21, 15, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/MFN.pyx":31
 *     """
 * 
 *     Type            = MFNType             # <<<<<<<<<<<<<<
 *     ConvergedReason = MFNConvergedReason
 * 
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_MFNType); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 31, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_MFN->tp_dict, __pyx_n_s_Type, __pyx_t_2) < 0) __PYX_ERR(21, 31, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_MFN);

  /* "SLEPc/MFN.pyx":32
 * 
 *     Type            = MFNType
 *     ConvergedReason = MFNConvergedReason             # <<<<<<<<<<<<<<
 * 
 *     def __cinit__(self):
 */
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_MFNConvergedReason); if (unlikely(!__pyx_t_2)) __PYX_ERR(21, 32, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem((PyObject *)__pyx_ptype_8slepc4py_5SLEPc_MFN->tp_dict, __pyx_n_s_ConvergedReason, __pyx_t_2) < 0) __PYX_ERR(21, 32, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  PyType_Modified(__pyx_ptype_8slepc4py_5SLEPc_MFN);

  /* "SLEPc/MFN.pyx":442
 * # -----------------------------------------------------------------------------
 * 
 * del MFNType             # <<<<<<<<<<<<<<
 * del MFNConvergedReason
 * 
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_MFNType) < 0) __PYX_ERR(21, 442, __pyx_L1_error)

  /* "SLEPc/MFN.pyx":443
 * 
 * del MFNType
 * del MFNConvergedReason             # <<<<<<<<<<<<<<
 * 
 * # -----------------------------------------------------------------------------
 */
  if (__Pyx_PyObject_DelAttrStr(__pyx_m, __pyx_n_s_MFNConvergedReason) < 0) __PYX_ERR(21, 443, __pyx_L1_error)

  /* "SLEPc/SLEPc.pyx":256
 * # -----------------------------------------------------------------------------
 * 
 * def _initialize(args=None):             # <<<<<<<<<<<<<<
 *     cdef int ready = initialize(args)
 *     if ready: register(NULL)
 */
  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_8slepc4py_5SLEPc_1_initialize, NULL, __pyx_n_s_slepc4py_SLEPc); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 256, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_initialize, __pyx_t_2) < 0) __PYX_ERR(4, 256, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "SLEPc/SLEPc.pyx":260
 *     if ready: register(NULL)
 * 
 * def _finalize():             # <<<<<<<<<<<<<<
 *     finalize()
 * 
 */
  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_8slepc4py_5SLEPc_3_finalize, NULL, __pyx_n_s_slepc4py_SLEPc); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 260, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_finalize, __pyx_t_2) < 0) __PYX_ERR(4, 260, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /*--- Wrapped vars code ---*/

  if (__Pyx_RegisterCleanup()) __PYX_ERR(23, 1, __pyx_L1_error);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  if (__pyx_m) {
    if (__pyx_d) {
      __Pyx_AddTraceback("init slepc4py.SLEPc", __pyx_clineno, __pyx_lineno, __pyx_filename);
    }
    Py_CLEAR(__pyx_m);
  } else if (!PyErr_Occurred()) {
    PyErr_SetString(PyExc_ImportError, "init slepc4py.SLEPc");
  }
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  #if CYTHON_PEP489_MULTI_PHASE_INIT
  return (__pyx_m != NULL) ? 0 : -1;
  #elif PY_MAJOR_VERSION >= 3
  return __pyx_m;
  #else
  return;
  #endif
}

static CYTHON_SMALL_CODE void __Pyx_CleanupGlobals(void) {
  Py_CLEAR(__pyx_tuple_);
  Py_CLEAR(__pyx_tuple__3);
  Py_CLEAR(__pyx_tuple__5);
  Py_CLEAR(__pyx_tuple__6);
  Py_CLEAR(__pyx_tuple__7);
  Py_CLEAR(__pyx_tuple__8);
  Py_CLEAR(__pyx_tuple__9);
  Py_CLEAR(__pyx_tuple__10);
  Py_CLEAR(__pyx_tuple__11);
  Py_CLEAR(__pyx_tuple__12);
  Py_CLEAR(__pyx_tuple__13);
  Py_CLEAR(__pyx_tuple__14);
  Py_CLEAR(__pyx_tuple__15);
  Py_CLEAR(__pyx_tuple__16);
  Py_CLEAR(__pyx_tuple__17);
  Py_CLEAR(__pyx_tuple__18);
  Py_CLEAR(__pyx_tuple__19);
  Py_CLEAR(__pyx_tuple__20);
  Py_CLEAR(__pyx_tuple__21);
  Py_CLEAR(__pyx_tuple__22);
  Py_CLEAR(__pyx_tuple__23);
  Py_CLEAR(__pyx_tuple__24);
  Py_CLEAR(__pyx_tuple__25);
  Py_CLEAR(__pyx_tuple__26);
  Py_CLEAR(__pyx_tuple__27);
  Py_CLEAR(__pyx_tuple__28);
  Py_CLEAR(__pyx_tuple__29);
  Py_CLEAR(__pyx_tuple__30);
  Py_CLEAR(__pyx_tuple__31);
  Py_CLEAR(__pyx_tuple__32);
  Py_CLEAR(__pyx_tuple__33);
  Py_CLEAR(__pyx_tuple__34);
  Py_CLEAR(__pyx_tuple__35);
  Py_CLEAR(__pyx_tuple__36);
  Py_CLEAR(__pyx_tuple__37);
  Py_CLEAR(__pyx_tuple__38);
  Py_CLEAR(__pyx_tuple__39);
  Py_CLEAR(__pyx_tuple__40);
  Py_CLEAR(__pyx_tuple__41);
  Py_CLEAR(__pyx_tuple__42);
  Py_CLEAR(__pyx_tuple__43);
  Py_CLEAR(__pyx_tuple__44);
  Py_CLEAR(__pyx_tuple__45);
  Py_CLEAR(__pyx_tuple__46);
  Py_CLEAR(__pyx_tuple__47);
  Py_CLEAR(__pyx_tuple__48);
  Py_CLEAR(__pyx_tuple__49);
  Py_CLEAR(__pyx_tuple__50);
  Py_CLEAR(__pyx_tuple__51);
  Py_CLEAR(__pyx_tuple__52);
  Py_CLEAR(__pyx_tuple__53);
  Py_CLEAR(__pyx_tuple__54);
  Py_CLEAR(__pyx_tuple__55);
  Py_CLEAR(__pyx_tuple__56);
  Py_CLEAR(__pyx_tuple__57);
  Py_CLEAR(__pyx_tuple__58);
  Py_CLEAR(__pyx_tuple__59);
  Py_CLEAR(__pyx_tuple__60);
  Py_CLEAR(__pyx_tuple__61);
  Py_CLEAR(__pyx_tuple__62);
  Py_CLEAR(__pyx_tuple__63);
  Py_CLEAR(__pyx_tuple__64);
  Py_CLEAR(__pyx_tuple__65);
  Py_CLEAR(__pyx_tuple__66);
  Py_CLEAR(__pyx_tuple__67);
  Py_CLEAR(__pyx_tuple__68);
  Py_CLEAR(__pyx_tuple__69);
  Py_CLEAR(__pyx_tuple__70);
  Py_CLEAR(__pyx_codeobj__71);
  Py_CLEAR(__pyx_codeobj__72);
  /* CodeObjectCache.cleanup */
  if (__pyx_code_cache.entries) {
      __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
      int i, count = __pyx_code_cache.count;
      __pyx_code_cache.count = 0;
      __pyx_code_cache.max_count = 0;
      __pyx_code_cache.entries = NULL;
      for (i=0; i<count; i++) {
          Py_DECREF(entries[i].code_object);
      }
      PyMem_Free(entries);
  }

}
static void __pyx_module_cleanup(CYTHON_UNUSED PyObject *self) {
  /*--- Global cleanup code ---*/
  Py_CLEAR(__pyx_v_8slepc4py_5SLEPc_PetscError);
  __Pyx_CleanupGlobals();
  /*--- Type import cleanup code ---*/
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_AO);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_Comm);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_DM);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_DMLabel);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_DS);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_DualSpace);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_FE);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_IS);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_KSP);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_LGMap);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_Mat);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_MatPartitioning);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_NullSpace);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_Object);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_PC);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_Partitioner);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_Quad);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_Random);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_SF);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_SNES);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_Scatter);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_Section);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_Space);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_TAO);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_TS);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_Vec);
  Py_CLEAR(__pyx_ptype_8petsc4py_5PETSc_Viewer);
  Py_CLEAR(__pyx_ptype_8slepc4py_5SLEPc_dtype);
  Py_CLEAR(__pyx_ptype_8slepc4py_5SLEPc_ndarray);
  /*--- Builtin cleanup code ---*/
  Py_CLEAR(__pyx_builtin_object);
  Py_CLEAR(__pyx_builtin_MemoryError);
  Py_CLEAR(__pyx_builtin_TypeError);
  Py_CLEAR(__pyx_builtin_ValueError);
  Py_CLEAR(__pyx_builtin_range);
  /*--- Intern cleanup code ---*/
  Py_CLEAR(__pyx_empty_tuple);
  Py_CLEAR(__pyx_d);
  Py_CLEAR(__pyx_cython_runtime);
  Py_CLEAR(__pyx_b);
}

/* --- Runtime support code --- */
/* Refnanny */
#if CYTHON_REFNANNY
static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
    PyObject *m = NULL, *p = NULL;
    void *r = NULL;
    m = PyImport_ImportModule(modname);
    if (!m) goto end;
    p = PyObject_GetAttrString(m, "RefNannyAPI");
    if (!p) goto end;
    r = PyLong_AsVoidPtr(p);
end:
    Py_XDECREF(p);
    Py_XDECREF(m);
    return (__Pyx_RefNannyAPIStruct *)r;
}
#endif

/* PyObjectGetAttrStr */
#if CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_getattro))
        return tp->tp_getattro(obj, attr_name);
#if PY_MAJOR_VERSION < 3
    if (likely(tp->tp_getattr))
        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
#endif
    return PyObject_GetAttr(obj, attr_name);
}
#endif

/* GetBuiltinName */
static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
    if (unlikely(!result)) {
        PyErr_Format(PyExc_NameError,
#if PY_MAJOR_VERSION >= 3
            "name '%U' is not defined", name);
#else
            "name '%.200s' is not defined", PyString_AS_STRING(name));
#endif
    }
    return result;
}

/* decode_c_bytes */
static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes(
         const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop,
         const char* encoding, const char* errors,
         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
    if (unlikely((start < 0) | (stop < 0))) {
        if (start < 0) {
            start += length;
            if (start < 0)
                start = 0;
        }
        if (stop < 0)
            stop += length;
    }
    if (stop > length)
        stop = length;
    if (unlikely(stop <= start))
        return __Pyx_NewRef(__pyx_empty_unicode);
    length = stop - start;
    cstring += start;
    if (decode_func) {
        return decode_func(cstring, length, errors);
    } else {
        return PyUnicode_Decode(cstring, length, encoding, errors);
    }
}

/* PyFunctionFastCall */
#if CYTHON_FAST_PYCALL
static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
                                               PyObject *globals) {
    PyFrameObject *f;
    PyThreadState *tstate = __Pyx_PyThreadState_Current;
    PyObject **fastlocals;
    Py_ssize_t i;
    PyObject *result;
    assert(globals != NULL);
    /* XXX Perhaps we should create a specialized
       PyFrame_New() that doesn't take locals, but does
       take builtins without sanity checking them.
       */
    assert(tstate != NULL);
    f = PyFrame_New(tstate, co, globals, NULL);
    if (f == NULL) {
        return NULL;
    }
    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
    for (i = 0; i < na; i++) {
        Py_INCREF(*args);
        fastlocals[i] = *args++;
    }
    result = PyEval_EvalFrameEx(f,0);
    ++tstate->recursion_depth;
    Py_DECREF(f);
    --tstate->recursion_depth;
    return result;
}
#if 1 || PY_VERSION_HEX < 0x030600B1
static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
    PyObject *globals = PyFunction_GET_GLOBALS(func);
    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
    PyObject *closure;
#if PY_MAJOR_VERSION >= 3
    PyObject *kwdefs;
#endif
    PyObject *kwtuple, **k;
    PyObject **d;
    Py_ssize_t nd;
    Py_ssize_t nk;
    PyObject *result;
    assert(kwargs == NULL || PyDict_Check(kwargs));
    nk = kwargs ? PyDict_Size(kwargs) : 0;
    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
        return NULL;
    }
    if (
#if PY_MAJOR_VERSION >= 3
            co->co_kwonlyargcount == 0 &&
#endif
            likely(kwargs == NULL || nk == 0) &&
            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
        if (argdefs == NULL && co->co_argcount == nargs) {
            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
            goto done;
        }
        else if (nargs == 0 && argdefs != NULL
                 && co->co_argcount == Py_SIZE(argdefs)) {
            /* function called with no arguments, but all parameters have
               a default value: use default values as arguments .*/
            args = &PyTuple_GET_ITEM(argdefs, 0);
            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
            goto done;
        }
    }
    if (kwargs != NULL) {
        Py_ssize_t pos, i;
        kwtuple = PyTuple_New(2 * nk);
        if (kwtuple == NULL) {
            result = NULL;
            goto done;
        }
        k = &PyTuple_GET_ITEM(kwtuple, 0);
        pos = i = 0;
        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
            Py_INCREF(k[i]);
            Py_INCREF(k[i+1]);
            i += 2;
        }
        nk = i / 2;
    }
    else {
        kwtuple = NULL;
        k = NULL;
    }
    closure = PyFunction_GET_CLOSURE(func);
#if PY_MAJOR_VERSION >= 3
    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
#endif
    if (argdefs != NULL) {
        d = &PyTuple_GET_ITEM(argdefs, 0);
        nd = Py_SIZE(argdefs);
    }
    else {
        d = NULL;
        nd = 0;
    }
#if PY_MAJOR_VERSION >= 3
    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
                               args, (int)nargs,
                               k, (int)nk,
                               d, (int)nd, kwdefs, closure);
#else
    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
                               args, (int)nargs,
                               k, (int)nk,
                               d, (int)nd, closure);
#endif
    Py_XDECREF(kwtuple);
done:
    Py_LeaveRecursiveCall();
    return result;
}
#endif
#endif

/* PyObjectCall */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
    PyObject *result;
    ternaryfunc call = Py_TYPE(func)->tp_call;
    if (unlikely(!call))
        return PyObject_Call(func, arg, kw);
    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
        return NULL;
    result = (*call)(func, arg, kw);
    Py_LeaveRecursiveCall();
    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
        PyErr_SetString(
            PyExc_SystemError,
            "NULL result without error in PyObject_Call");
    }
    return result;
}
#endif

/* PyObjectCallMethO */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
    PyObject *self, *result;
    PyCFunction cfunc;
    cfunc = PyCFunction_GET_FUNCTION(func);
    self = PyCFunction_GET_SELF(func);
    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
        return NULL;
    result = cfunc(self, arg);
    Py_LeaveRecursiveCall();
    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
        PyErr_SetString(
            PyExc_SystemError,
            "NULL result without error in PyObject_Call");
    }
    return result;
}
#endif

/* PyObjectCallNoArg */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
#if CYTHON_FAST_PYCALL
    if (PyFunction_Check(func)) {
        return __Pyx_PyFunction_FastCall(func, NULL, 0);
    }
#endif
#ifdef __Pyx_CyFunction_USED
    if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func)))
#else
    if (likely(PyCFunction_Check(func)))
#endif
    {
        if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
            return __Pyx_PyObject_CallMethO(func, NULL);
        }
    }
    return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
}
#endif

/* PyCFunctionFastCall */
#if CYTHON_FAST_PYCCALL
static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
    PyObject *self = PyCFunction_GET_SELF(func);
    int flags = PyCFunction_GET_FLAGS(func);
    assert(PyCFunction_Check(func));
    assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)));
    assert(nargs >= 0);
    assert(nargs == 0 || args != NULL);
    /* _PyCFunction_FastCallDict() must not be called with an exception set,
       because it may clear it (directly or indirectly) and so the
       caller loses its exception */
    assert(!PyErr_Occurred());
    if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) {
        return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL);
    } else {
        return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs);
    }
}
#endif

/* PyObjectCallOneArg */
#if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
    PyObject *result;
    PyObject *args = PyTuple_New(1);
    if (unlikely(!args)) return NULL;
    Py_INCREF(arg);
    PyTuple_SET_ITEM(args, 0, arg);
    result = __Pyx_PyObject_Call(func, args, NULL);
    Py_DECREF(args);
    return result;
}
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
#if CYTHON_FAST_PYCALL
    if (PyFunction_Check(func)) {
        return __Pyx_PyFunction_FastCall(func, &arg, 1);
    }
#endif
    if (likely(PyCFunction_Check(func))) {
        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
            return __Pyx_PyObject_CallMethO(func, arg);
#if CYTHON_FAST_PYCCALL
        } else if (__Pyx_PyFastCFunction_Check(func)) {
            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
#endif
        }
    }
    return __Pyx__PyObject_CallOneArg(func, arg);
}
#else
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
    PyObject *result;
    PyObject *args = PyTuple_Pack(1, arg);
    if (unlikely(!args)) return NULL;
    result = __Pyx_PyObject_Call(func, args, NULL);
    Py_DECREF(args);
    return result;
}
#endif

/* RaiseArgTupleInvalid */
static void __Pyx_RaiseArgtupleInvalid(
    const char* func_name,
    int exact,
    Py_ssize_t num_min,
    Py_ssize_t num_max,
    Py_ssize_t num_found)
{
    Py_ssize_t num_expected;
    const char *more_or_less;
    if (num_found < num_min) {
        num_expected = num_min;
        more_or_less = "at least";
    } else {
        num_expected = num_max;
        more_or_less = "at most";
    }
    if (exact) {
        more_or_less = "exactly";
    }
    PyErr_Format(PyExc_TypeError,
                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
                 func_name, more_or_less, num_expected,
                 (num_expected == 1) ? "" : "s", num_found);
}

/* KeywordStringCheck */
static int __Pyx_CheckKeywordStrings(
    PyObject *kwdict,
    const char* function_name,
    int kw_allowed)
{
    PyObject* key = 0;
    Py_ssize_t pos = 0;
#if CYTHON_COMPILING_IN_PYPY
    if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0))
        goto invalid_keyword;
    return 1;
#else
    while (PyDict_Next(kwdict, &pos, &key, 0)) {
        #if PY_MAJOR_VERSION < 3
        if (unlikely(!PyString_Check(key)))
        #endif
            if (unlikely(!PyUnicode_Check(key)))
                goto invalid_keyword_type;
    }
    if ((!kw_allowed) && unlikely(key))
        goto invalid_keyword;
    return 1;
invalid_keyword_type:
    PyErr_Format(PyExc_TypeError,
        "%.200s() keywords must be strings", function_name);
    return 0;
#endif
invalid_keyword:
    PyErr_Format(PyExc_TypeError,
    #if PY_MAJOR_VERSION < 3
        "%.200s() got an unexpected keyword argument '%.200s'",
        function_name, PyString_AsString(key));
    #else
        "%s() got an unexpected keyword argument '%U'",
        function_name, key);
    #endif
    return 0;
}

/* PyErrFetchRestore */
#if CYTHON_FAST_THREAD_STATE
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
    PyObject *tmp_type, *tmp_value, *tmp_tb;
    tmp_type = tstate->curexc_type;
    tmp_value = tstate->curexc_value;
    tmp_tb = tstate->curexc_traceback;
    tstate->curexc_type = type;
    tstate->curexc_value = value;
    tstate->curexc_traceback = tb;
    Py_XDECREF(tmp_type);
    Py_XDECREF(tmp_value);
    Py_XDECREF(tmp_tb);
}
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
    *type = tstate->curexc_type;
    *value = tstate->curexc_value;
    *tb = tstate->curexc_traceback;
    tstate->curexc_type = 0;
    tstate->curexc_value = 0;
    tstate->curexc_traceback = 0;
}
#endif

/* WriteUnraisableException */
static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno,
                                  CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename,
                                  int full_traceback, CYTHON_UNUSED int nogil) {
    PyObject *old_exc, *old_val, *old_tb;
    PyObject *ctx;
    __Pyx_PyThreadState_declare
#ifdef WITH_THREAD
    PyGILState_STATE state;
    if (nogil)
        state = PyGILState_Ensure();
#ifdef _MSC_VER
    else state = (PyGILState_STATE)-1;
#endif
#endif
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
    if (full_traceback) {
        Py_XINCREF(old_exc);
        Py_XINCREF(old_val);
        Py_XINCREF(old_tb);
        __Pyx_ErrRestore(old_exc, old_val, old_tb);
        PyErr_PrintEx(1);
    }
    #if PY_MAJOR_VERSION < 3
    ctx = PyString_FromString(name);
    #else
    ctx = PyUnicode_FromString(name);
    #endif
    __Pyx_ErrRestore(old_exc, old_val, old_tb);
    if (!ctx) {
        PyErr_WriteUnraisable(Py_None);
    } else {
        PyErr_WriteUnraisable(ctx);
        Py_DECREF(ctx);
    }
#ifdef WITH_THREAD
    if (nogil)
        PyGILState_Release(state);
#endif
}

/* RaiseTooManyValuesToUnpack */
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
    PyErr_Format(PyExc_ValueError,
                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
}

/* RaiseNeedMoreValuesToUnpack */
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
    PyErr_Format(PyExc_ValueError,
                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
                 index, (index == 1) ? "" : "s");
}

/* IterFinish */
static CYTHON_INLINE int __Pyx_IterFinish(void) {
#if CYTHON_FAST_THREAD_STATE
    PyThreadState *tstate = __Pyx_PyThreadState_Current;
    PyObject* exc_type = tstate->curexc_type;
    if (unlikely(exc_type)) {
        if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) {
            PyObject *exc_value, *exc_tb;
            exc_value = tstate->curexc_value;
            exc_tb = tstate->curexc_traceback;
            tstate->curexc_type = 0;
            tstate->curexc_value = 0;
            tstate->curexc_traceback = 0;
            Py_DECREF(exc_type);
            Py_XDECREF(exc_value);
            Py_XDECREF(exc_tb);
            return 0;
        } else {
            return -1;
        }
    }
    return 0;
#else
    if (unlikely(PyErr_Occurred())) {
        if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
            PyErr_Clear();
            return 0;
        } else {
            return -1;
        }
    }
    return 0;
#endif
}

/* UnpackItemEndCheck */
static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
    if (unlikely(retval)) {
        Py_DECREF(retval);
        __Pyx_RaiseTooManyValuesError(expected);
        return -1;
    } else {
        return __Pyx_IterFinish();
    }
    return 0;
}

/* GetTopmostException */
#if CYTHON_USE_EXC_INFO_STACK
static _PyErr_StackItem *
__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
{
    _PyErr_StackItem *exc_info = tstate->exc_info;
    while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) &&
           exc_info->previous_item != NULL)
    {
        exc_info = exc_info->previous_item;
    }
    return exc_info;
}
#endif

/* SaveResetException */
#if CYTHON_FAST_THREAD_STATE
static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
    #if CYTHON_USE_EXC_INFO_STACK
    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
    *type = exc_info->exc_type;
    *value = exc_info->exc_value;
    *tb = exc_info->exc_traceback;
    #else
    *type = tstate->exc_type;
    *value = tstate->exc_value;
    *tb = tstate->exc_traceback;
    #endif
    Py_XINCREF(*type);
    Py_XINCREF(*value);
    Py_XINCREF(*tb);
}
static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
    PyObject *tmp_type, *tmp_value, *tmp_tb;
    #if CYTHON_USE_EXC_INFO_STACK
    _PyErr_StackItem *exc_info = tstate->exc_info;
    tmp_type = exc_info->exc_type;
    tmp_value = exc_info->exc_value;
    tmp_tb = exc_info->exc_traceback;
    exc_info->exc_type = type;
    exc_info->exc_value = value;
    exc_info->exc_traceback = tb;
    #else
    tmp_type = tstate->exc_type;
    tmp_value = tstate->exc_value;
    tmp_tb = tstate->exc_traceback;
    tstate->exc_type = type;
    tstate->exc_value = value;
    tstate->exc_traceback = tb;
    #endif
    Py_XDECREF(tmp_type);
    Py_XDECREF(tmp_value);
    Py_XDECREF(tmp_tb);
}
#endif

/* PyErrExceptionMatches */
#if CYTHON_FAST_THREAD_STATE
static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
    Py_ssize_t i, n;
    n = PyTuple_GET_SIZE(tuple);
#if PY_MAJOR_VERSION >= 3
    for (i=0; i<n; i++) {
        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
    }
#endif
    for (i=0; i<n; i++) {
        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
    }
    return 0;
}
static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
    PyObject *exc_type = tstate->curexc_type;
    if (exc_type == err) return 1;
    if (unlikely(!exc_type)) return 0;
    if (unlikely(PyTuple_Check(err)))
        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
    return __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
}
#endif

/* GetException */
#if CYTHON_FAST_THREAD_STATE
static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb)
#else
static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
#endif
{
    PyObject *local_type, *local_value, *local_tb;
#if CYTHON_FAST_THREAD_STATE
    PyObject *tmp_type, *tmp_value, *tmp_tb;
    local_type = tstate->curexc_type;
    local_value = tstate->curexc_value;
    local_tb = tstate->curexc_traceback;
    tstate->curexc_type = 0;
    tstate->curexc_value = 0;
    tstate->curexc_traceback = 0;
#else
    PyErr_Fetch(&local_type, &local_value, &local_tb);
#endif
    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
#if CYTHON_FAST_THREAD_STATE
    if (unlikely(tstate->curexc_type))
#else
    if (unlikely(PyErr_Occurred()))
#endif
        goto bad;
    #if PY_MAJOR_VERSION >= 3
    if (local_tb) {
        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
            goto bad;
    }
    #endif
    Py_XINCREF(local_tb);
    Py_XINCREF(local_type);
    Py_XINCREF(local_value);
    *type = local_type;
    *value = local_value;
    *tb = local_tb;
#if CYTHON_FAST_THREAD_STATE
    #if CYTHON_USE_EXC_INFO_STACK
    {
        _PyErr_StackItem *exc_info = tstate->exc_info;
        tmp_type = exc_info->exc_type;
        tmp_value = exc_info->exc_value;
        tmp_tb = exc_info->exc_traceback;
        exc_info->exc_type = local_type;
        exc_info->exc_value = local_value;
        exc_info->exc_traceback = local_tb;
    }
    #else
    tmp_type = tstate->exc_type;
    tmp_value = tstate->exc_value;
    tmp_tb = tstate->exc_traceback;
    tstate->exc_type = local_type;
    tstate->exc_value = local_value;
    tstate->exc_traceback = local_tb;
    #endif
    Py_XDECREF(tmp_type);
    Py_XDECREF(tmp_value);
    Py_XDECREF(tmp_tb);
#else
    PyErr_SetExcInfo(local_type, local_value, local_tb);
#endif
    return 0;
bad:
    *type = 0;
    *value = 0;
    *tb = 0;
    Py_XDECREF(local_type);
    Py_XDECREF(local_value);
    Py_XDECREF(local_tb);
    return -1;
}

/* RaiseException */
#if PY_MAJOR_VERSION < 3
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
                        CYTHON_UNUSED PyObject *cause) {
    __Pyx_PyThreadState_declare
    Py_XINCREF(type);
    if (!value || value == Py_None)
        value = NULL;
    else
        Py_INCREF(value);
    if (!tb || tb == Py_None)
        tb = NULL;
    else {
        Py_INCREF(tb);
        if (!PyTraceBack_Check(tb)) {
            PyErr_SetString(PyExc_TypeError,
                "raise: arg 3 must be a traceback or None");
            goto raise_error;
        }
    }
    if (PyType_Check(type)) {
#if CYTHON_COMPILING_IN_PYPY
        if (!value) {
            Py_INCREF(Py_None);
            value = Py_None;
        }
#endif
        PyErr_NormalizeException(&type, &value, &tb);
    } else {
        if (value) {
            PyErr_SetString(PyExc_TypeError,
                "instance exception may not have a separate value");
            goto raise_error;
        }
        value = type;
        type = (PyObject*) Py_TYPE(type);
        Py_INCREF(type);
        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
            PyErr_SetString(PyExc_TypeError,
                "raise: exception class must be a subclass of BaseException");
            goto raise_error;
        }
    }
    __Pyx_PyThreadState_assign
    __Pyx_ErrRestore(type, value, tb);
    return;
raise_error:
    Py_XDECREF(value);
    Py_XDECREF(type);
    Py_XDECREF(tb);
    return;
}
#else
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
    PyObject* owned_instance = NULL;
    if (tb == Py_None) {
        tb = 0;
    } else if (tb && !PyTraceBack_Check(tb)) {
        PyErr_SetString(PyExc_TypeError,
            "raise: arg 3 must be a traceback or None");
        goto bad;
    }
    if (value == Py_None)
        value = 0;
    if (PyExceptionInstance_Check(type)) {
        if (value) {
            PyErr_SetString(PyExc_TypeError,
                "instance exception may not have a separate value");
            goto bad;
        }
        value = type;
        type = (PyObject*) Py_TYPE(value);
    } else if (PyExceptionClass_Check(type)) {
        PyObject *instance_class = NULL;
        if (value && PyExceptionInstance_Check(value)) {
            instance_class = (PyObject*) Py_TYPE(value);
            if (instance_class != type) {
                int is_subclass = PyObject_IsSubclass(instance_class, type);
                if (!is_subclass) {
                    instance_class = NULL;
                } else if (unlikely(is_subclass == -1)) {
                    goto bad;
                } else {
                    type = instance_class;
                }
            }
        }
        if (!instance_class) {
            PyObject *args;
            if (!value)
                args = PyTuple_New(0);
            else if (PyTuple_Check(value)) {
                Py_INCREF(value);
                args = value;
            } else
                args = PyTuple_Pack(1, value);
            if (!args)
                goto bad;
            owned_instance = PyObject_Call(type, args, NULL);
            Py_DECREF(args);
            if (!owned_instance)
                goto bad;
            value = owned_instance;
            if (!PyExceptionInstance_Check(value)) {
                PyErr_Format(PyExc_TypeError,
                             "calling %R should have returned an instance of "
                             "BaseException, not %R",
                             type, Py_TYPE(value));
                goto bad;
            }
        }
    } else {
        PyErr_SetString(PyExc_TypeError,
            "raise: exception class must be a subclass of BaseException");
        goto bad;
    }
    if (cause) {
        PyObject *fixed_cause;
        if (cause == Py_None) {
            fixed_cause = NULL;
        } else if (PyExceptionClass_Check(cause)) {
            fixed_cause = PyObject_CallObject(cause, NULL);
            if (fixed_cause == NULL)
                goto bad;
        } else if (PyExceptionInstance_Check(cause)) {
            fixed_cause = cause;
            Py_INCREF(fixed_cause);
        } else {
            PyErr_SetString(PyExc_TypeError,
                            "exception causes must derive from "
                            "BaseException");
            goto bad;
        }
        PyException_SetCause(value, fixed_cause);
    }
    PyErr_SetObject(type, value);
    if (tb) {
#if CYTHON_COMPILING_IN_PYPY
        PyObject *tmp_type, *tmp_value, *tmp_tb;
        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
        Py_INCREF(tb);
        PyErr_Restore(tmp_type, tmp_value, tb);
        Py_XDECREF(tmp_tb);
#else
        PyThreadState *tstate = __Pyx_PyThreadState_Current;
        PyObject* tmp_tb = tstate->curexc_traceback;
        if (tb != tmp_tb) {
            Py_INCREF(tb);
            tstate->curexc_traceback = tb;
            Py_XDECREF(tmp_tb);
        }
#endif
    }
bad:
    Py_XDECREF(owned_instance);
    return;
}
#endif

/* RaiseDoubleKeywords */
static void __Pyx_RaiseDoubleKeywordsError(
    const char* func_name,
    PyObject* kw_name)
{
    PyErr_Format(PyExc_TypeError,
        #if PY_MAJOR_VERSION >= 3
        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
        #else
        "%s() got multiple values for keyword argument '%s'", func_name,
        PyString_AsString(kw_name));
        #endif
}

/* ParseKeywords */
static int __Pyx_ParseOptionalKeywords(
    PyObject *kwds,
    PyObject **argnames[],
    PyObject *kwds2,
    PyObject *values[],
    Py_ssize_t num_pos_args,
    const char* function_name)
{
    PyObject *key = 0, *value = 0;
    Py_ssize_t pos = 0;
    PyObject*** name;
    PyObject*** first_kw_arg = argnames + num_pos_args;
    while (PyDict_Next(kwds, &pos, &key, &value)) {
        name = first_kw_arg;
        while (*name && (**name != key)) name++;
        if (*name) {
            values[name-argnames] = value;
            continue;
        }
        name = first_kw_arg;
        #if PY_MAJOR_VERSION < 3
        if (likely(PyString_Check(key))) {
            while (*name) {
                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
                        && _PyString_Eq(**name, key)) {
                    values[name-argnames] = value;
                    break;
                }
                name++;
            }
            if (*name) continue;
            else {
                PyObject*** argname = argnames;
                while (argname != first_kw_arg) {
                    if ((**argname == key) || (
                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
                             && _PyString_Eq(**argname, key))) {
                        goto arg_passed_twice;
                    }
                    argname++;
                }
            }
        } else
        #endif
        if (likely(PyUnicode_Check(key))) {
            while (*name) {
                int cmp = (**name == key) ? 0 :
                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                    (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
                #endif
                    PyUnicode_Compare(**name, key);
                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                if (cmp == 0) {
                    values[name-argnames] = value;
                    break;
                }
                name++;
            }
            if (*name) continue;
            else {
                PyObject*** argname = argnames;
                while (argname != first_kw_arg) {
                    int cmp = (**argname == key) ? 0 :
                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                        (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
                    #endif
                        PyUnicode_Compare(**argname, key);
                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                    if (cmp == 0) goto arg_passed_twice;
                    argname++;
                }
            }
        } else
            goto invalid_keyword_type;
        if (kwds2) {
            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
        } else {
            goto invalid_keyword;
        }
    }
    return 0;
arg_passed_twice:
    __Pyx_RaiseDoubleKeywordsError(function_name, key);
    goto bad;
invalid_keyword_type:
    PyErr_Format(PyExc_TypeError,
        "%.200s() keywords must be strings", function_name);
    goto bad;
invalid_keyword:
    PyErr_Format(PyExc_TypeError,
    #if PY_MAJOR_VERSION < 3
        "%.200s() got an unexpected keyword argument '%.200s'",
        function_name, PyString_AsString(key));
    #else
        "%s() got an unexpected keyword argument '%U'",
        function_name, key);
    #endif
bad:
    return -1;
}

/* PyObjectCall2Args */
static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
    PyObject *args, *result = NULL;
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(function)) {
        PyObject *args[2] = {arg1, arg2};
        return __Pyx_PyFunction_FastCall(function, args, 2);
    }
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(function)) {
        PyObject *args[2] = {arg1, arg2};
        return __Pyx_PyCFunction_FastCall(function, args, 2);
    }
    #endif
    args = PyTuple_New(2);
    if (unlikely(!args)) goto done;
    Py_INCREF(arg1);
    PyTuple_SET_ITEM(args, 0, arg1);
    Py_INCREF(arg2);
    PyTuple_SET_ITEM(args, 1, arg2);
    Py_INCREF(function);
    result = __Pyx_PyObject_Call(function, args, NULL);
    Py_DECREF(args);
    Py_DECREF(function);
done:
    return result;
}

/* PyObjectGetMethod */
static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
    PyObject *attr;
#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
    PyTypeObject *tp = Py_TYPE(obj);
    PyObject *descr;
    descrgetfunc f = NULL;
    PyObject **dictptr, *dict;
    int meth_found = 0;
    assert (*method == NULL);
    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
        attr = __Pyx_PyObject_GetAttrStr(obj, name);
        goto try_unpack;
    }
    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
        return 0;
    }
    descr = _PyType_Lookup(tp, name);
    if (likely(descr != NULL)) {
        Py_INCREF(descr);
#if PY_MAJOR_VERSION >= 3
        #ifdef __Pyx_CyFunction_USED
        if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
        #else
        if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type)))
        #endif
#else
        #ifdef __Pyx_CyFunction_USED
        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
        #else
        if (likely(PyFunction_Check(descr)))
        #endif
#endif
        {
            meth_found = 1;
        } else {
            f = Py_TYPE(descr)->tp_descr_get;
            if (f != NULL && PyDescr_IsData(descr)) {
                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
                Py_DECREF(descr);
                goto try_unpack;
            }
        }
    }
    dictptr = _PyObject_GetDictPtr(obj);
    if (dictptr != NULL && (dict = *dictptr) != NULL) {
        Py_INCREF(dict);
        attr = __Pyx_PyDict_GetItemStr(dict, name);
        if (attr != NULL) {
            Py_INCREF(attr);
            Py_DECREF(dict);
            Py_XDECREF(descr);
            goto try_unpack;
        }
        Py_DECREF(dict);
    }
    if (meth_found) {
        *method = descr;
        return 1;
    }
    if (f != NULL) {
        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
        Py_DECREF(descr);
        goto try_unpack;
    }
    if (descr != NULL) {
        *method = descr;
        return 0;
    }
    PyErr_Format(PyExc_AttributeError,
#if PY_MAJOR_VERSION >= 3
                 "'%.50s' object has no attribute '%U'",
                 tp->tp_name, name);
#else
                 "'%.50s' object has no attribute '%.400s'",
                 tp->tp_name, PyString_AS_STRING(name));
#endif
    return 0;
#else
    attr = __Pyx_PyObject_GetAttrStr(obj, name);
    goto try_unpack;
#endif
try_unpack:
#if CYTHON_UNPACK_METHODS
    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
        PyObject *function = PyMethod_GET_FUNCTION(attr);
        Py_INCREF(function);
        Py_DECREF(attr);
        *method = function;
        return 1;
    }
#endif
    *method = attr;
    return 0;
}

/* PyObjectCallMethod1 */
static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) {
    PyObject *result = __Pyx_PyObject_CallOneArg(method, arg);
    Py_DECREF(method);
    return result;
}
static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) {
    PyObject *method = NULL, *result;
    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
    if (likely(is_method)) {
        result = __Pyx_PyObject_Call2Args(method, obj, arg);
        Py_DECREF(method);
        return result;
    }
    if (unlikely(!method)) return NULL;
    return __Pyx__PyObject_CallMethod1(method, arg);
}

/* append */
static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
    if (likely(PyList_CheckExact(L))) {
        if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1;
    } else {
        PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_n_s_append, x);
        if (unlikely(!retval))
            return -1;
        Py_DECREF(retval);
    }
    return 0;
}

/* GetItemInt */
static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
    PyObject *r;
    if (!j) return NULL;
    r = PyObject_GetItem(o, j);
    Py_DECREF(j);
    return r;
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
                                                              CYTHON_NCP_UNUSED int wraparound,
                                                              CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    Py_ssize_t wrapped_i = i;
    if (wraparound & unlikely(i < 0)) {
        wrapped_i += PyList_GET_SIZE(o);
    }
    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) {
        PyObject *r = PyList_GET_ITEM(o, wrapped_i);
        Py_INCREF(r);
        return r;
    }
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
#else
    return PySequence_GetItem(o, i);
#endif
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
                                                              CYTHON_NCP_UNUSED int wraparound,
                                                              CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    Py_ssize_t wrapped_i = i;
    if (wraparound & unlikely(i < 0)) {
        wrapped_i += PyTuple_GET_SIZE(o);
    }
    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) {
        PyObject *r = PyTuple_GET_ITEM(o, wrapped_i);
        Py_INCREF(r);
        return r;
    }
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
#else
    return PySequence_GetItem(o, i);
#endif
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list,
                                                     CYTHON_NCP_UNUSED int wraparound,
                                                     CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
    if (is_list || PyList_CheckExact(o)) {
        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
        if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) {
            PyObject *r = PyList_GET_ITEM(o, n);
            Py_INCREF(r);
            return r;
        }
    }
    else if (PyTuple_CheckExact(o)) {
        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
        if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) {
            PyObject *r = PyTuple_GET_ITEM(o, n);
            Py_INCREF(r);
            return r;
        }
    } else {
        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
        if (likely(m && m->sq_item)) {
            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
                Py_ssize_t l = m->sq_length(o);
                if (likely(l >= 0)) {
                    i += l;
                } else {
                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
                        return NULL;
                    PyErr_Clear();
                }
            }
            return m->sq_item(o, i);
        }
    }
#else
    if (is_list || PySequence_Check(o)) {
        return PySequence_GetItem(o, i);
    }
#endif
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
}

/* ArgTypeTest */
static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
{
    if (unlikely(!type)) {
        PyErr_SetString(PyExc_SystemError, "Missing type object");
        return 0;
    }
    else if (exact) {
        #if PY_MAJOR_VERSION == 2
        if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
        #endif
    }
    else {
        if (likely(__Pyx_TypeCheck(obj, type))) return 1;
    }
    PyErr_Format(PyExc_TypeError,
        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
        name, type->tp_name, Py_TYPE(obj)->tp_name);
    return 0;
}

/* ExtTypeTest */
static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
    if (unlikely(!type)) {
        PyErr_SetString(PyExc_SystemError, "Missing type object");
        return 0;
    }
    if (likely(__Pyx_TypeCheck(obj, type)))
        return 1;
    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
                 Py_TYPE(obj)->tp_name, type->tp_name);
    return 0;
}

/* PyDictVersioning */
#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
    PyObject *dict = Py_TYPE(obj)->tp_dict;
    return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
}
static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
    PyObject **dictptr = NULL;
    Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
    if (offset) {
#if CYTHON_COMPILING_IN_CPYTHON
        dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
#else
        dictptr = _PyObject_GetDictPtr(obj);
#endif
    }
    return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
}
static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
    PyObject *dict = Py_TYPE(obj)->tp_dict;
    if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
        return 0;
    return obj_dict_version == __Pyx_get_object_dict_version(obj);
}
#endif

/* GetModuleGlobalName */
#if CYTHON_USE_DICT_VERSIONS
static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value)
#else
static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
#endif
{
    PyObject *result;
#if !CYTHON_AVOID_BORROWED_REFS
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
    result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);
    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
    if (likely(result)) {
        return __Pyx_NewRef(result);
    } else if (unlikely(PyErr_Occurred())) {
        return NULL;
    }
#else
    result = PyDict_GetItem(__pyx_d, name);
    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
    if (likely(result)) {
        return __Pyx_NewRef(result);
    }
#endif
#else
    result = PyObject_GetItem(__pyx_d, name);
    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
    if (likely(result)) {
        return __Pyx_NewRef(result);
    }
    PyErr_Clear();
#endif
    return __Pyx_GetBuiltinName(name);
}

/* SwapException */
#if CYTHON_FAST_THREAD_STATE
static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
    PyObject *tmp_type, *tmp_value, *tmp_tb;
    #if CYTHON_USE_EXC_INFO_STACK
    _PyErr_StackItem *exc_info = tstate->exc_info;
    tmp_type = exc_info->exc_type;
    tmp_value = exc_info->exc_value;
    tmp_tb = exc_info->exc_traceback;
    exc_info->exc_type = *type;
    exc_info->exc_value = *value;
    exc_info->exc_traceback = *tb;
    #else
    tmp_type = tstate->exc_type;
    tmp_value = tstate->exc_value;
    tmp_tb = tstate->exc_traceback;
    tstate->exc_type = *type;
    tstate->exc_value = *value;
    tstate->exc_traceback = *tb;
    #endif
    *type = tmp_type;
    *value = tmp_value;
    *tb = tmp_tb;
}
#else
static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) {
    PyObject *tmp_type, *tmp_value, *tmp_tb;
    PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb);
    PyErr_SetExcInfo(*type, *value, *tb);
    *type = tmp_type;
    *value = tmp_value;
    *tb = tmp_tb;
}
#endif

/* CallNextTpDealloc */
static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc) {
    PyTypeObject* type = Py_TYPE(obj);
    while (type && type->tp_dealloc != current_tp_dealloc)
        type = type->tp_base;
    while (type && type->tp_dealloc == current_tp_dealloc)
        type = type->tp_base;
    if (type)
        type->tp_dealloc(obj);
}

/* CallNextTpTraverse */
static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse) {
    PyTypeObject* type = Py_TYPE(obj);
    while (type && type->tp_traverse != current_tp_traverse)
        type = type->tp_base;
    while (type && type->tp_traverse == current_tp_traverse)
        type = type->tp_base;
    if (type && type->tp_traverse)
        return type->tp_traverse(obj, v, a);
    return 0;
}

/* CallNextTpClear */
static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_clear) {
    PyTypeObject* type = Py_TYPE(obj);
    while (type && type->tp_clear != current_tp_clear)
        type = type->tp_base;
    while (type && type->tp_clear == current_tp_clear)
        type = type->tp_base;
    if (type && type->tp_clear)
        type->tp_clear(obj);
}

/* TypeImport */
#ifndef __PYX_HAVE_RT_ImportType
#define __PYX_HAVE_RT_ImportType
static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name,
    size_t size, enum __Pyx_ImportType_CheckSize check_size)
{
    PyObject *result = 0;
    char warning[200];
    Py_ssize_t basicsize;
#ifdef Py_LIMITED_API
    PyObject *py_basicsize;
#endif
    result = PyObject_GetAttrString(module, class_name);
    if (!result)
        goto bad;
    if (!PyType_Check(result)) {
        PyErr_Format(PyExc_TypeError,
            "%.200s.%.200s is not a type object",
            module_name, class_name);
        goto bad;
    }
#ifndef Py_LIMITED_API
    basicsize = ((PyTypeObject *)result)->tp_basicsize;
#else
    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
    if (!py_basicsize)
        goto bad;
    basicsize = PyLong_AsSsize_t(py_basicsize);
    Py_DECREF(py_basicsize);
    py_basicsize = 0;
    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
        goto bad;
#endif
    if ((size_t)basicsize < size) {
        PyErr_Format(PyExc_ValueError,
            "%.200s.%.200s size changed, may indicate binary incompatibility. "
            "Expected %zd from C header, got %zd from PyObject",
            module_name, class_name, size, basicsize);
        goto bad;
    }
    if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) {
        PyErr_Format(PyExc_ValueError,
            "%.200s.%.200s size changed, may indicate binary incompatibility. "
            "Expected %zd from C header, got %zd from PyObject",
            module_name, class_name, size, basicsize);
        goto bad;
    }
    else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) {
        PyOS_snprintf(warning, sizeof(warning),
            "%s.%s size changed, may indicate binary incompatibility. "
            "Expected %zd from C header, got %zd from PyObject",
            module_name, class_name, size, basicsize);
        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
    }
    return (PyTypeObject *)result;
bad:
    Py_XDECREF(result);
    return NULL;
}
#endif

/* GetVTable */
static void* __Pyx_GetVtable(PyObject *dict) {
    void* ptr;
    PyObject *ob = PyObject_GetItem(dict, __pyx_n_s_pyx_vtable);
    if (!ob)
        goto bad;
#if PY_VERSION_HEX >= 0x02070000
    ptr = PyCapsule_GetPointer(ob, 0);
#else
    ptr = PyCObject_AsVoidPtr(ob);
#endif
    if (!ptr && !PyErr_Occurred())
        PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type");
    Py_DECREF(ob);
    return ptr;
bad:
    Py_XDECREF(ob);
    return NULL;
}

/* PyObject_GenericGetAttrNoDict */
#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
    PyErr_Format(PyExc_AttributeError,
#if PY_MAJOR_VERSION >= 3
                 "'%.50s' object has no attribute '%U'",
                 tp->tp_name, attr_name);
#else
                 "'%.50s' object has no attribute '%.400s'",
                 tp->tp_name, PyString_AS_STRING(attr_name));
#endif
    return NULL;
}
static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
    PyObject *descr;
    PyTypeObject *tp = Py_TYPE(obj);
    if (unlikely(!PyString_Check(attr_name))) {
        return PyObject_GenericGetAttr(obj, attr_name);
    }
    assert(!tp->tp_dictoffset);
    descr = _PyType_Lookup(tp, attr_name);
    if (unlikely(!descr)) {
        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
    }
    Py_INCREF(descr);
    #if PY_MAJOR_VERSION < 3
    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
    #endif
    {
        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
        if (unlikely(f)) {
            PyObject *res = f(descr, obj, (PyObject *)tp);
            Py_DECREF(descr);
            return res;
        }
    }
    return descr;
}
#endif

/* PyObject_GenericGetAttr */
#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
        return PyObject_GenericGetAttr(obj, attr_name);
    }
    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
}
#endif

/* SetVTable */
static int __Pyx_SetVtable(PyObject *dict, void *vtable) {
#if PY_VERSION_HEX >= 0x02070000
    PyObject *ob = PyCapsule_New(vtable, 0, 0);
#else
    PyObject *ob = PyCObject_FromVoidPtr(vtable, 0);
#endif
    if (!ob)
        goto bad;
    if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0)
        goto bad;
    Py_DECREF(ob);
    return 0;
bad:
    Py_XDECREF(ob);
    return -1;
}

/* Import */
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
    PyObject *empty_list = 0;
    PyObject *module = 0;
    PyObject *global_dict = 0;
    PyObject *empty_dict = 0;
    PyObject *list;
    #if PY_MAJOR_VERSION < 3
    PyObject *py_import;
    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
    if (!py_import)
        goto bad;
    #endif
    if (from_list)
        list = from_list;
    else {
        empty_list = PyList_New(0);
        if (!empty_list)
            goto bad;
        list = empty_list;
    }
    global_dict = PyModule_GetDict(__pyx_m);
    if (!global_dict)
        goto bad;
    empty_dict = PyDict_New();
    if (!empty_dict)
        goto bad;
    {
        #if PY_MAJOR_VERSION >= 3
        if (level == -1) {
            if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) {
                module = PyImport_ImportModuleLevelObject(
                    name, global_dict, empty_dict, list, 1);
                if (!module) {
                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
                        goto bad;
                    PyErr_Clear();
                }
            }
            level = 0;
        }
        #endif
        if (!module) {
            #if PY_MAJOR_VERSION < 3
            PyObject *py_level = PyInt_FromLong(level);
            if (!py_level)
                goto bad;
            module = PyObject_CallFunctionObjArgs(py_import,
                name, global_dict, empty_dict, list, py_level, (PyObject *)NULL);
            Py_DECREF(py_level);
            #else
            module = PyImport_ImportModuleLevelObject(
                name, global_dict, empty_dict, list, level);
            #endif
        }
    }
bad:
    #if PY_MAJOR_VERSION < 3
    Py_XDECREF(py_import);
    #endif
    Py_XDECREF(empty_list);
    Py_XDECREF(empty_dict);
    return module;
}

/* ImportFrom */
static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
        PyErr_Format(PyExc_ImportError,
        #if PY_MAJOR_VERSION < 3
            "cannot import name %.230s", PyString_AS_STRING(name));
        #else
            "cannot import name %S", name);
        #endif
    }
    return value;
}

/* ClassMethod */
static PyObject* __Pyx_Method_ClassMethod(PyObject *method) {
#if CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM <= 0x05080000
    if (PyObject_TypeCheck(method, &PyWrapperDescr_Type)) {
        return PyClassMethod_New(method);
    }
#else
#if CYTHON_COMPILING_IN_PYSTON || CYTHON_COMPILING_IN_PYPY
    if (PyMethodDescr_Check(method))
#else
    #if PY_MAJOR_VERSION == 2
    static PyTypeObject *methoddescr_type = NULL;
    if (methoddescr_type == NULL) {
       PyObject *meth = PyObject_GetAttrString((PyObject*)&PyList_Type, "append");
       if (!meth) return NULL;
       methoddescr_type = Py_TYPE(meth);
       Py_DECREF(meth);
    }
    #else
    PyTypeObject *methoddescr_type = &PyMethodDescr_Type;
    #endif
    if (__Pyx_TypeCheck(method, methoddescr_type))
#endif
    {
        PyMethodDescrObject *descr = (PyMethodDescrObject *)method;
        #if PY_VERSION_HEX < 0x03020000
        PyTypeObject *d_type = descr->d_type;
        #else
        PyTypeObject *d_type = descr->d_common.d_type;
        #endif
        return PyDescr_NewClassMethod(d_type, descr->d_method);
    }
#endif
    else if (PyMethod_Check(method)) {
        return PyClassMethod_New(PyMethod_GET_FUNCTION(method));
    }
    else {
        return PyClassMethod_New(method);
    }
}

/* GetNameInClass */
static PyObject *__Pyx_GetGlobalNameAfterAttributeLookup(PyObject *name) {
    PyObject *result;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
        return NULL;
    __Pyx_PyErr_Clear();
    __Pyx_GetModuleGlobalNameUncached(result, name);
    return result;
}
static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name) {
    PyObject *result;
    result = __Pyx_PyObject_GetAttrStr(nmspace, name);
    if (!result) {
        result = __Pyx_GetGlobalNameAfterAttributeLookup(name);
    }
    return result;
}

/* CalculateMetaclass */
static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) {
    Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases);
    for (i=0; i < nbases; i++) {
        PyTypeObject *tmptype;
        PyObject *tmp = PyTuple_GET_ITEM(bases, i);
        tmptype = Py_TYPE(tmp);
#if PY_MAJOR_VERSION < 3
        if (tmptype == &PyClass_Type)
            continue;
#endif
        if (!metaclass) {
            metaclass = tmptype;
            continue;
        }
        if (PyType_IsSubtype(metaclass, tmptype))
            continue;
        if (PyType_IsSubtype(tmptype, metaclass)) {
            metaclass = tmptype;
            continue;
        }
        PyErr_SetString(PyExc_TypeError,
                        "metaclass conflict: "
                        "the metaclass of a derived class "
                        "must be a (non-strict) subclass "
                        "of the metaclasses of all its bases");
        return NULL;
    }
    if (!metaclass) {
#if PY_MAJOR_VERSION < 3
        metaclass = &PyClass_Type;
#else
        metaclass = &PyType_Type;
#endif
    }
    Py_INCREF((PyObject*) metaclass);
    return (PyObject*) metaclass;
}

/* Py3ClassCreate */
static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name,
                                           PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) {
    PyObject *ns;
    if (metaclass) {
        PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare);
        if (prep) {
            PyObject *pargs = PyTuple_Pack(2, name, bases);
            if (unlikely(!pargs)) {
                Py_DECREF(prep);
                return NULL;
            }
            ns = PyObject_Call(prep, pargs, mkw);
            Py_DECREF(prep);
            Py_DECREF(pargs);
        } else {
            if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError)))
                return NULL;
            PyErr_Clear();
            ns = PyDict_New();
        }
    } else {
        ns = PyDict_New();
    }
    if (unlikely(!ns))
        return NULL;
    if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad;
    if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad;
    if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad;
    return ns;
bad:
    Py_DECREF(ns);
    return NULL;
}
static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases,
                                      PyObject *dict, PyObject *mkw,
                                      int calculate_metaclass, int allow_py2_metaclass) {
    PyObject *result, *margs;
    PyObject *owned_metaclass = NULL;
    if (allow_py2_metaclass) {
        owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass);
        if (owned_metaclass) {
            metaclass = owned_metaclass;
        } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) {
            PyErr_Clear();
        } else {
            return NULL;
        }
    }
    if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) {
        metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases);
        Py_XDECREF(owned_metaclass);
        if (unlikely(!metaclass))
            return NULL;
        owned_metaclass = metaclass;
    }
    margs = PyTuple_Pack(3, name, bases, dict);
    if (unlikely(!margs)) {
        result = NULL;
    } else {
        result = PyObject_Call(metaclass, margs, mkw);
        Py_DECREF(margs);
    }
    Py_XDECREF(owned_metaclass);
    return result;
}

/* PyObjectSetAttrStr */
#if CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) {
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_setattro))
        return tp->tp_setattro(obj, attr_name, value);
#if PY_MAJOR_VERSION < 3
    if (likely(tp->tp_setattr))
        return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value);
#endif
    return PyObject_SetAttr(obj, attr_name, value);
}
#endif

/* RegisterModuleCleanup */
#if PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY
static PyObject* __pyx_module_cleanup_atexit(PyObject *module, CYTHON_UNUSED PyObject *unused) {
    __pyx_module_cleanup(module);
    Py_INCREF(Py_None); return Py_None;
}
static int __Pyx_RegisterCleanup(void) {
    static PyMethodDef cleanup_def = {
        "__cleanup", (PyCFunction)__pyx_module_cleanup_atexit, METH_NOARGS, 0};
    PyObject *cleanup_func = 0;
    PyObject *atexit = 0;
    PyObject *reg = 0;
    PyObject *args = 0;
    PyObject *res = 0;
    int ret = -1;
    cleanup_func = PyCFunction_New(&cleanup_def, 0);
    if (!cleanup_func)
        goto bad;
    atexit = PyImport_ImportModule("atexit");
    if (!atexit)
        goto bad;
    reg = PyObject_GetAttrString(atexit, "_exithandlers");
    if (reg && PyList_Check(reg)) {
        PyObject *a, *kw;
        a = PyTuple_New(0);
        kw = PyDict_New();
        if (!a || !kw) {
            Py_XDECREF(a);
            Py_XDECREF(kw);
            goto bad;
        }
        args = PyTuple_Pack(3, cleanup_func, a, kw);
        Py_DECREF(a);
        Py_DECREF(kw);
        if (!args)
            goto bad;
        ret = PyList_Insert(reg, 0, args);
    } else {
        if (!reg)
            PyErr_Clear();
        Py_XDECREF(reg);
        reg = PyObject_GetAttrString(atexit, "register");
        if (!reg)
            goto bad;
        args = PyTuple_Pack(1, cleanup_func);
        if (!args)
            goto bad;
        res = PyObject_CallObject(reg, args);
        if (!res)
            goto bad;
        ret = 0;
    }
bad:
    Py_XDECREF(cleanup_func);
    Py_XDECREF(atexit);
    Py_XDECREF(reg);
    Py_XDECREF(args);
    Py_XDECREF(res);
    return ret;
}
#endif

/* CLineInTraceback */
#ifndef CYTHON_CLINE_IN_TRACEBACK
static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) {
    PyObject *use_cline;
    PyObject *ptype, *pvalue, *ptraceback;
#if CYTHON_COMPILING_IN_CPYTHON
    PyObject **cython_runtime_dict;
#endif
    if (unlikely(!__pyx_cython_runtime)) {
        return c_line;
    }
    __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
#if CYTHON_COMPILING_IN_CPYTHON
    cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime);
    if (likely(cython_runtime_dict)) {
        __PYX_PY_DICT_LOOKUP_IF_MODIFIED(
            use_cline, *cython_runtime_dict,
            __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback))
    } else
#endif
    {
      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
      if (use_cline_obj) {
        use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
        Py_DECREF(use_cline_obj);
      } else {
        PyErr_Clear();
        use_cline = NULL;
      }
    }
    if (!use_cline) {
        c_line = 0;
        (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False);
    }
    else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {
        c_line = 0;
    }
    __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
    return c_line;
}
#endif

/* CodeObjectCache */
static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
    int start = 0, mid = 0, end = count - 1;
    if (end >= 0 && code_line > entries[end].code_line) {
        return count;
    }
    while (start < end) {
        mid = start + (end - start) / 2;
        if (code_line < entries[mid].code_line) {
            end = mid;
        } else if (code_line > entries[mid].code_line) {
             start = mid + 1;
        } else {
            return mid;
        }
    }
    if (code_line <= entries[mid].code_line) {
        return mid;
    } else {
        return mid + 1;
    }
}
static PyCodeObject *__pyx_find_code_object(int code_line) {
    PyCodeObject* code_object;
    int pos;
    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
        return NULL;
    }
    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
        return NULL;
    }
    code_object = __pyx_code_cache.entries[pos].code_object;
    Py_INCREF(code_object);
    return code_object;
}
static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
    int pos, i;
    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
    if (unlikely(!code_line)) {
        return;
    }
    if (unlikely(!entries)) {
        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
        if (likely(entries)) {
            __pyx_code_cache.entries = entries;
            __pyx_code_cache.max_count = 64;
            __pyx_code_cache.count = 1;
            entries[0].code_line = code_line;
            entries[0].code_object = code_object;
            Py_INCREF(code_object);
        }
        return;
    }
    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
        PyCodeObject* tmp = entries[pos].code_object;
        entries[pos].code_object = code_object;
        Py_DECREF(tmp);
        return;
    }
    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
        int new_max = __pyx_code_cache.max_count + 64;
        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
            __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry));
        if (unlikely(!entries)) {
            return;
        }
        __pyx_code_cache.entries = entries;
        __pyx_code_cache.max_count = new_max;
    }
    for (i=__pyx_code_cache.count; i>pos; i--) {
        entries[i] = entries[i-1];
    }
    entries[pos].code_line = code_line;
    entries[pos].code_object = code_object;
    __pyx_code_cache.count++;
    Py_INCREF(code_object);
}

/* AddTraceback */
#include "compile.h"
#include "frameobject.h"
#include "traceback.h"
#if PY_VERSION_HEX >= 0x030b00a6
  #ifndef Py_BUILD_CORE
    #define Py_BUILD_CORE 1
  #endif
  #include "internal/pycore_frame.h"
#endif
static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
            const char *funcname, int c_line,
            int py_line, const char *filename) {
    PyCodeObject *py_code = NULL;
    PyObject *py_funcname = NULL;
    #if PY_MAJOR_VERSION < 3
    PyObject *py_srcfile = NULL;
    py_srcfile = PyString_FromString(filename);
    if (!py_srcfile) goto bad;
    #endif
    if (c_line) {
        #if PY_MAJOR_VERSION < 3
        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
        if (!py_funcname) goto bad;
        #else
        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
        if (!py_funcname) goto bad;
        funcname = PyUnicode_AsUTF8(py_funcname);
        if (!funcname) goto bad;
        #endif
    }
    else {
        #if PY_MAJOR_VERSION < 3
        py_funcname = PyString_FromString(funcname);
        if (!py_funcname) goto bad;
        #endif
    }
    #if PY_MAJOR_VERSION < 3
    py_code = __Pyx_PyCode_New(
        0,
        0,
        0,
        0,
        0,
        __pyx_empty_bytes, /*PyObject *code,*/
        __pyx_empty_tuple, /*PyObject *consts,*/
        __pyx_empty_tuple, /*PyObject *names,*/
        __pyx_empty_tuple, /*PyObject *varnames,*/
        __pyx_empty_tuple, /*PyObject *freevars,*/
        __pyx_empty_tuple, /*PyObject *cellvars,*/
        py_srcfile,   /*PyObject *filename,*/
        py_funcname,  /*PyObject *name,*/
        py_line,
        __pyx_empty_bytes  /*PyObject *lnotab*/
    );
    Py_DECREF(py_srcfile);
    #else
    py_code = PyCode_NewEmpty(filename, funcname, py_line);
    #endif
    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
    return py_code;
bad:
    Py_XDECREF(py_funcname);
    #if PY_MAJOR_VERSION < 3
    Py_XDECREF(py_srcfile);
    #endif
    return NULL;
}
static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename) {
    PyCodeObject *py_code = 0;
    PyFrameObject *py_frame = 0;
    PyThreadState *tstate = __Pyx_PyThreadState_Current;
    PyObject *ptype, *pvalue, *ptraceback;
    if (c_line) {
        c_line = __Pyx_CLineForTraceback(tstate, c_line);
    }
    py_code = __pyx_find_code_object(c_line ? -c_line : py_line);
    if (!py_code) {
        __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
        py_code = __Pyx_CreateCodeObjectForTraceback(
            funcname, c_line, py_line, filename);
        if (!py_code) {
            /* If the code object creation fails, then we should clear the
               fetched exception references and propagate the new exception */
            Py_XDECREF(ptype);
            Py_XDECREF(pvalue);
            Py_XDECREF(ptraceback);
            goto bad;
        }
        __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
        __pyx_insert_code_object(c_line ? -c_line : py_line, py_code);
    }
    py_frame = PyFrame_New(
        tstate,            /*PyThreadState *tstate,*/
        py_code,           /*PyCodeObject *code,*/
        __pyx_d,    /*PyObject *globals,*/
        0                  /*PyObject *locals*/
    );
    if (!py_frame) goto bad;
    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
    PyTraceBack_Here(py_frame);
bad:
    Py_XDECREF(py_code);
    Py_XDECREF(py_frame);
}

/* CIntFromPyVerify */
#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
    {\
        func_type value = func_value;\
        if (sizeof(target_type) < sizeof(func_type)) {\
            if (unlikely(value != (func_type) (target_type) value)) {\
                func_type zero = 0;\
                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
                    return (target_type) -1;\
                if (is_unsigned && unlikely(value < zero))\
                    goto raise_neg_overflow;\
                else\
                    goto raise_overflow;\
            }\
        }\
        return (target_type) value;\
    }

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const int neg_one = (int) -1, const_zero = (int) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(int) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(int) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(int) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(int),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_STMatMode(STMatMode value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const STMatMode neg_one = (STMatMode) -1, const_zero = (STMatMode) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(STMatMode) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(STMatMode) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(STMatMode) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(STMatMode) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(STMatMode) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(STMatMode),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_BVOrthogType(BVOrthogType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const BVOrthogType neg_one = (BVOrthogType) -1, const_zero = (BVOrthogType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(BVOrthogType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(BVOrthogType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(BVOrthogType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(BVOrthogType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(BVOrthogType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(BVOrthogType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_BVOrthogRefineType(BVOrthogRefineType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const BVOrthogRefineType neg_one = (BVOrthogRefineType) -1, const_zero = (BVOrthogRefineType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(BVOrthogRefineType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(BVOrthogRefineType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(BVOrthogRefineType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(BVOrthogRefineType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(BVOrthogRefineType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(BVOrthogRefineType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_BVOrthogBlockType(BVOrthogBlockType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const BVOrthogBlockType neg_one = (BVOrthogBlockType) -1, const_zero = (BVOrthogBlockType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(BVOrthogBlockType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(BVOrthogBlockType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(BVOrthogBlockType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(BVOrthogBlockType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(BVOrthogBlockType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(BVOrthogBlockType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_BVMatMultType(BVMatMultType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const BVMatMultType neg_one = (BVMatMultType) -1, const_zero = (BVMatMultType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(BVMatMultType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(BVMatMultType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(BVMatMultType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(BVMatMultType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(BVMatMultType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(BVMatMultType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_BVSVDMethod(BVSVDMethod value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const BVSVDMethod neg_one = (BVSVDMethod) -1, const_zero = (BVSVDMethod) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(BVSVDMethod) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(BVSVDMethod) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(BVSVDMethod) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(BVSVDMethod) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(BVSVDMethod) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(BVSVDMethod),
                                     little, !is_unsigned);
    }
}

/* CIntFromPy */
static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const int neg_one = (int) -1, const_zero = (int) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(int) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (int) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (int) 0;
                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
                case 2:
                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
                            return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
                            return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
                            return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (int) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(int) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (int) 0;
                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
                            return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
                            return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
                            return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
                            return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
                            return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
                            return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(int) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            int val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (int) -1;
        }
    } else {
        int val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (int) -1;
        val = __Pyx_PyInt_As_int(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to int");
    return (int) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to int");
    return (int) -1;
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_DSStateType(DSStateType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const DSStateType neg_one = (DSStateType) -1, const_zero = (DSStateType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(DSStateType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(DSStateType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(DSStateType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(DSStateType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(DSStateType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(DSStateType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_DSMatType(DSMatType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const DSMatType neg_one = (DSMatType) -1, const_zero = (DSMatType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(DSMatType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(DSMatType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(DSMatType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(DSMatType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(DSMatType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(DSMatType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_DSParallelType(DSParallelType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const DSParallelType neg_one = (DSParallelType) -1, const_zero = (DSParallelType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(DSParallelType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(DSParallelType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(DSParallelType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(DSParallelType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(DSParallelType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(DSParallelType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_FNCombineType(FNCombineType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const FNCombineType neg_one = (FNCombineType) -1, const_zero = (FNCombineType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(FNCombineType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(FNCombineType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(FNCombineType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(FNCombineType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(FNCombineType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(FNCombineType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_FNParallelType(FNParallelType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const FNParallelType neg_one = (FNParallelType) -1, const_zero = (FNParallelType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(FNParallelType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(FNParallelType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(FNParallelType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(FNParallelType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(FNParallelType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(FNParallelType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSCISSQuadRule(EPSCISSQuadRule value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSCISSQuadRule neg_one = (EPSCISSQuadRule) -1, const_zero = (EPSCISSQuadRule) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(EPSCISSQuadRule) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(EPSCISSQuadRule) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSCISSQuadRule) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(EPSCISSQuadRule) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSCISSQuadRule) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(EPSCISSQuadRule),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSProblemType(EPSProblemType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSProblemType neg_one = (EPSProblemType) -1, const_zero = (EPSProblemType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(EPSProblemType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(EPSProblemType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSProblemType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(EPSProblemType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSProblemType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(EPSProblemType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSExtraction(EPSExtraction value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSExtraction neg_one = (EPSExtraction) -1, const_zero = (EPSExtraction) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(EPSExtraction) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(EPSExtraction) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSExtraction) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(EPSExtraction) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSExtraction) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(EPSExtraction),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSBalance(EPSBalance value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSBalance neg_one = (EPSBalance) -1, const_zero = (EPSBalance) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(EPSBalance) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(EPSBalance) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSBalance) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(EPSBalance) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSBalance) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(EPSBalance),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSErrorType(EPSErrorType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSErrorType neg_one = (EPSErrorType) -1, const_zero = (EPSErrorType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(EPSErrorType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(EPSErrorType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSErrorType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(EPSErrorType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSErrorType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(EPSErrorType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSWhich(EPSWhich value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSWhich neg_one = (EPSWhich) -1, const_zero = (EPSWhich) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(EPSWhich) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(EPSWhich) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSWhich) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(EPSWhich) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSWhich) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(EPSWhich),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSConv(EPSConv value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSConv neg_one = (EPSConv) -1, const_zero = (EPSConv) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(EPSConv) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(EPSConv) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSConv) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(EPSConv) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSConv) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(EPSConv),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSStop(EPSStop value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSStop neg_one = (EPSStop) -1, const_zero = (EPSStop) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(EPSStop) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(EPSStop) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSStop) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(EPSStop) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSStop) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(EPSStop),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSConvergedReason(EPSConvergedReason value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSConvergedReason neg_one = (EPSConvergedReason) -1, const_zero = (EPSConvergedReason) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(EPSConvergedReason) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(EPSConvergedReason) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSConvergedReason) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(EPSConvergedReason) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSConvergedReason) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(EPSConvergedReason),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSPowerShiftType(EPSPowerShiftType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSPowerShiftType neg_one = (EPSPowerShiftType) -1, const_zero = (EPSPowerShiftType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(EPSPowerShiftType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(EPSPowerShiftType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSPowerShiftType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(EPSPowerShiftType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSPowerShiftType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(EPSPowerShiftType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSLanczosReorthogType(EPSLanczosReorthogType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSLanczosReorthogType neg_one = (EPSLanczosReorthogType) -1, const_zero = (EPSLanczosReorthogType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(EPSLanczosReorthogType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(EPSLanczosReorthogType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSLanczosReorthogType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(EPSLanczosReorthogType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSLanczosReorthogType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(EPSLanczosReorthogType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_EPSCISSExtraction(EPSCISSExtraction value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSCISSExtraction neg_one = (EPSCISSExtraction) -1, const_zero = (EPSCISSExtraction) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(EPSCISSExtraction) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(EPSCISSExtraction) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSCISSExtraction) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(EPSCISSExtraction) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(EPSCISSExtraction) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(EPSCISSExtraction),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SVDProblemType(SVDProblemType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const SVDProblemType neg_one = (SVDProblemType) -1, const_zero = (SVDProblemType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(SVDProblemType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(SVDProblemType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(SVDProblemType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(SVDProblemType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(SVDProblemType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(SVDProblemType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SVDErrorType(SVDErrorType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const SVDErrorType neg_one = (SVDErrorType) -1, const_zero = (SVDErrorType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(SVDErrorType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(SVDErrorType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(SVDErrorType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(SVDErrorType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(SVDErrorType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(SVDErrorType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SVDWhich(SVDWhich value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const SVDWhich neg_one = (SVDWhich) -1, const_zero = (SVDWhich) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(SVDWhich) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(SVDWhich) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(SVDWhich) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(SVDWhich) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(SVDWhich) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(SVDWhich),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SVDConv(SVDConv value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const SVDConv neg_one = (SVDConv) -1, const_zero = (SVDConv) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(SVDConv) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(SVDConv) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(SVDConv) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(SVDConv) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(SVDConv) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(SVDConv),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SVDStop(SVDStop value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const SVDStop neg_one = (SVDStop) -1, const_zero = (SVDStop) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(SVDStop) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(SVDStop) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(SVDStop) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(SVDStop) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(SVDStop) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(SVDStop),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SVDConvergedReason(SVDConvergedReason value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const SVDConvergedReason neg_one = (SVDConvergedReason) -1, const_zero = (SVDConvergedReason) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(SVDConvergedReason) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(SVDConvergedReason) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(SVDConvergedReason) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(SVDConvergedReason) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(SVDConvergedReason) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(SVDConvergedReason),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SVDTRLanczosGBidiag(SVDTRLanczosGBidiag value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const SVDTRLanczosGBidiag neg_one = (SVDTRLanczosGBidiag) -1, const_zero = (SVDTRLanczosGBidiag) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(SVDTRLanczosGBidiag) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(SVDTRLanczosGBidiag) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(SVDTRLanczosGBidiag) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(SVDTRLanczosGBidiag) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(SVDTRLanczosGBidiag) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(SVDTRLanczosGBidiag),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPProblemType(PEPProblemType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPProblemType neg_one = (PEPProblemType) -1, const_zero = (PEPProblemType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(PEPProblemType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(PEPProblemType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPProblemType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(PEPProblemType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPProblemType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(PEPProblemType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPWhich(PEPWhich value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPWhich neg_one = (PEPWhich) -1, const_zero = (PEPWhich) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(PEPWhich) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(PEPWhich) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPWhich) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(PEPWhich) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPWhich) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(PEPWhich),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPBasis(PEPBasis value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPBasis neg_one = (PEPBasis) -1, const_zero = (PEPBasis) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(PEPBasis) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(PEPBasis) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPBasis) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(PEPBasis) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPBasis) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(PEPBasis),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPScale(PEPScale value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPScale neg_one = (PEPScale) -1, const_zero = (PEPScale) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(PEPScale) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(PEPScale) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPScale) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(PEPScale) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPScale) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(PEPScale),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPRefine(PEPRefine value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPRefine neg_one = (PEPRefine) -1, const_zero = (PEPRefine) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(PEPRefine) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(PEPRefine) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPRefine) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(PEPRefine) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPRefine) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(PEPRefine),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPRefineScheme(PEPRefineScheme value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPRefineScheme neg_one = (PEPRefineScheme) -1, const_zero = (PEPRefineScheme) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(PEPRefineScheme) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(PEPRefineScheme) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPRefineScheme) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(PEPRefineScheme) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPRefineScheme) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(PEPRefineScheme),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPExtract(PEPExtract value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPExtract neg_one = (PEPExtract) -1, const_zero = (PEPExtract) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(PEPExtract) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(PEPExtract) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPExtract) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(PEPExtract) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPExtract) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(PEPExtract),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPErrorType(PEPErrorType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPErrorType neg_one = (PEPErrorType) -1, const_zero = (PEPErrorType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(PEPErrorType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(PEPErrorType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPErrorType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(PEPErrorType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPErrorType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(PEPErrorType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPConv(PEPConv value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPConv neg_one = (PEPConv) -1, const_zero = (PEPConv) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(PEPConv) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(PEPConv) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPConv) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(PEPConv) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPConv) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(PEPConv),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPStop(PEPStop value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPStop neg_one = (PEPStop) -1, const_zero = (PEPStop) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(PEPStop) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(PEPStop) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPStop) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(PEPStop) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPStop) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(PEPStop),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPConvergedReason(PEPConvergedReason value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPConvergedReason neg_one = (PEPConvergedReason) -1, const_zero = (PEPConvergedReason) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(PEPConvergedReason) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(PEPConvergedReason) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPConvergedReason) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(PEPConvergedReason) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPConvergedReason) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(PEPConvergedReason),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPJDProjection(PEPJDProjection value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPJDProjection neg_one = (PEPJDProjection) -1, const_zero = (PEPJDProjection) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(PEPJDProjection) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(PEPJDProjection) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPJDProjection) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(PEPJDProjection) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPJDProjection) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(PEPJDProjection),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PEPCISSExtraction(PEPCISSExtraction value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPCISSExtraction neg_one = (PEPCISSExtraction) -1, const_zero = (PEPCISSExtraction) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(PEPCISSExtraction) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(PEPCISSExtraction) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPCISSExtraction) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(PEPCISSExtraction) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PEPCISSExtraction) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(PEPCISSExtraction),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPProblemType(NEPProblemType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPProblemType neg_one = (NEPProblemType) -1, const_zero = (NEPProblemType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(NEPProblemType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(NEPProblemType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPProblemType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(NEPProblemType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPProblemType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(NEPProblemType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPErrorType(NEPErrorType value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPErrorType neg_one = (NEPErrorType) -1, const_zero = (NEPErrorType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(NEPErrorType) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(NEPErrorType) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPErrorType) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(NEPErrorType) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPErrorType) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(NEPErrorType),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPWhich(NEPWhich value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPWhich neg_one = (NEPWhich) -1, const_zero = (NEPWhich) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(NEPWhich) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(NEPWhich) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPWhich) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(NEPWhich) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPWhich) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(NEPWhich),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPConvergedReason(NEPConvergedReason value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPConvergedReason neg_one = (NEPConvergedReason) -1, const_zero = (NEPConvergedReason) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(NEPConvergedReason) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(NEPConvergedReason) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPConvergedReason) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(NEPConvergedReason) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPConvergedReason) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(NEPConvergedReason),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPRefine(NEPRefine value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPRefine neg_one = (NEPRefine) -1, const_zero = (NEPRefine) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(NEPRefine) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(NEPRefine) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPRefine) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(NEPRefine) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPRefine) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(NEPRefine),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPRefineScheme(NEPRefineScheme value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPRefineScheme neg_one = (NEPRefineScheme) -1, const_zero = (NEPRefineScheme) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(NEPRefineScheme) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(NEPRefineScheme) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPRefineScheme) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(NEPRefineScheme) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPRefineScheme) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(NEPRefineScheme),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPConv(NEPConv value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPConv neg_one = (NEPConv) -1, const_zero = (NEPConv) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(NEPConv) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(NEPConv) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPConv) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(NEPConv) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPConv) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(NEPConv),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPStop(NEPStop value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPStop neg_one = (NEPStop) -1, const_zero = (NEPStop) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(NEPStop) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(NEPStop) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPStop) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(NEPStop) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPStop) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(NEPStop),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_NEPCISSExtraction(NEPCISSExtraction value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPCISSExtraction neg_one = (NEPCISSExtraction) -1, const_zero = (NEPCISSExtraction) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(NEPCISSExtraction) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(NEPCISSExtraction) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPCISSExtraction) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(NEPCISSExtraction) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(NEPCISSExtraction) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(NEPCISSExtraction),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MFNConvergedReason(MFNConvergedReason value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const MFNConvergedReason neg_one = (MFNConvergedReason) -1, const_zero = (MFNConvergedReason) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(MFNConvergedReason) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(MFNConvergedReason) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(MFNConvergedReason) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(MFNConvergedReason) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(MFNConvergedReason) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(MFNConvergedReason),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const long neg_one = (long) -1, const_zero = (long) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(long) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(long) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(long) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(long),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PetscInt(PetscInt value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PetscInt neg_one = (PetscInt) -1, const_zero = (PetscInt) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(PetscInt) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(PetscInt) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PetscInt) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(PetscInt) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(PetscInt) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(PetscInt),
                                     little, !is_unsigned);
    }
}

/* CIntFromPy */
static CYTHON_INLINE PetscInt __Pyx_PyInt_As_PetscInt(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PetscInt neg_one = (PetscInt) -1, const_zero = (PetscInt) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(PetscInt) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(PetscInt, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (PetscInt) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PetscInt) 0;
                case  1: __PYX_VERIFY_RETURN_INT(PetscInt, digit, digits[0])
                case 2:
                    if (8 * sizeof(PetscInt) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscInt, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscInt) >= 2 * PyLong_SHIFT) {
                            return (PetscInt) (((((PetscInt)digits[1]) << PyLong_SHIFT) | (PetscInt)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PetscInt) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscInt, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscInt) >= 3 * PyLong_SHIFT) {
                            return (PetscInt) (((((((PetscInt)digits[2]) << PyLong_SHIFT) | (PetscInt)digits[1]) << PyLong_SHIFT) | (PetscInt)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PetscInt) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscInt, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscInt) >= 4 * PyLong_SHIFT) {
                            return (PetscInt) (((((((((PetscInt)digits[3]) << PyLong_SHIFT) | (PetscInt)digits[2]) << PyLong_SHIFT) | (PetscInt)digits[1]) << PyLong_SHIFT) | (PetscInt)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (PetscInt) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(PetscInt) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PetscInt, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PetscInt) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PetscInt, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PetscInt) 0;
                case -1: __PYX_VERIFY_RETURN_INT(PetscInt, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(PetscInt,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(PetscInt) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscInt, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscInt) - 1 > 2 * PyLong_SHIFT) {
                            return (PetscInt) (((PetscInt)-1)*(((((PetscInt)digits[1]) << PyLong_SHIFT) | (PetscInt)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(PetscInt) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscInt, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscInt) - 1 > 2 * PyLong_SHIFT) {
                            return (PetscInt) ((((((PetscInt)digits[1]) << PyLong_SHIFT) | (PetscInt)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(PetscInt) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscInt, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscInt) - 1 > 3 * PyLong_SHIFT) {
                            return (PetscInt) (((PetscInt)-1)*(((((((PetscInt)digits[2]) << PyLong_SHIFT) | (PetscInt)digits[1]) << PyLong_SHIFT) | (PetscInt)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PetscInt) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscInt, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscInt) - 1 > 3 * PyLong_SHIFT) {
                            return (PetscInt) ((((((((PetscInt)digits[2]) << PyLong_SHIFT) | (PetscInt)digits[1]) << PyLong_SHIFT) | (PetscInt)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(PetscInt) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscInt, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscInt) - 1 > 4 * PyLong_SHIFT) {
                            return (PetscInt) (((PetscInt)-1)*(((((((((PetscInt)digits[3]) << PyLong_SHIFT) | (PetscInt)digits[2]) << PyLong_SHIFT) | (PetscInt)digits[1]) << PyLong_SHIFT) | (PetscInt)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PetscInt) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscInt, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscInt) - 1 > 4 * PyLong_SHIFT) {
                            return (PetscInt) ((((((((((PetscInt)digits[3]) << PyLong_SHIFT) | (PetscInt)digits[2]) << PyLong_SHIFT) | (PetscInt)digits[1]) << PyLong_SHIFT) | (PetscInt)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(PetscInt) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PetscInt, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PetscInt) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PetscInt, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            PetscInt val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (PetscInt) -1;
        }
    } else {
        PetscInt val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (PetscInt) -1;
        val = __Pyx_PyInt_As_PetscInt(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to PetscInt");
    return (PetscInt) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to PetscInt");
    return (PetscInt) -1;
}

/* CIntFromPy */
static CYTHON_INLINE MatStructure __Pyx_PyInt_As_MatStructure(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const MatStructure neg_one = (MatStructure) -1, const_zero = (MatStructure) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(MatStructure) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(MatStructure, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (MatStructure) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (MatStructure) 0;
                case  1: __PYX_VERIFY_RETURN_INT(MatStructure, digit, digits[0])
                case 2:
                    if (8 * sizeof(MatStructure) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(MatStructure, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(MatStructure) >= 2 * PyLong_SHIFT) {
                            return (MatStructure) (((((MatStructure)digits[1]) << PyLong_SHIFT) | (MatStructure)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(MatStructure) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(MatStructure, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(MatStructure) >= 3 * PyLong_SHIFT) {
                            return (MatStructure) (((((((MatStructure)digits[2]) << PyLong_SHIFT) | (MatStructure)digits[1]) << PyLong_SHIFT) | (MatStructure)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(MatStructure) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(MatStructure, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(MatStructure) >= 4 * PyLong_SHIFT) {
                            return (MatStructure) (((((((((MatStructure)digits[3]) << PyLong_SHIFT) | (MatStructure)digits[2]) << PyLong_SHIFT) | (MatStructure)digits[1]) << PyLong_SHIFT) | (MatStructure)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (MatStructure) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(MatStructure) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(MatStructure, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(MatStructure) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(MatStructure, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (MatStructure) 0;
                case -1: __PYX_VERIFY_RETURN_INT(MatStructure, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(MatStructure,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(MatStructure) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(MatStructure, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(MatStructure) - 1 > 2 * PyLong_SHIFT) {
                            return (MatStructure) (((MatStructure)-1)*(((((MatStructure)digits[1]) << PyLong_SHIFT) | (MatStructure)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(MatStructure) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(MatStructure, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(MatStructure) - 1 > 2 * PyLong_SHIFT) {
                            return (MatStructure) ((((((MatStructure)digits[1]) << PyLong_SHIFT) | (MatStructure)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(MatStructure) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(MatStructure, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(MatStructure) - 1 > 3 * PyLong_SHIFT) {
                            return (MatStructure) (((MatStructure)-1)*(((((((MatStructure)digits[2]) << PyLong_SHIFT) | (MatStructure)digits[1]) << PyLong_SHIFT) | (MatStructure)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(MatStructure) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(MatStructure, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(MatStructure) - 1 > 3 * PyLong_SHIFT) {
                            return (MatStructure) ((((((((MatStructure)digits[2]) << PyLong_SHIFT) | (MatStructure)digits[1]) << PyLong_SHIFT) | (MatStructure)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(MatStructure) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(MatStructure, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(MatStructure) - 1 > 4 * PyLong_SHIFT) {
                            return (MatStructure) (((MatStructure)-1)*(((((((((MatStructure)digits[3]) << PyLong_SHIFT) | (MatStructure)digits[2]) << PyLong_SHIFT) | (MatStructure)digits[1]) << PyLong_SHIFT) | (MatStructure)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(MatStructure) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(MatStructure, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(MatStructure) - 1 > 4 * PyLong_SHIFT) {
                            return (MatStructure) ((((((((((MatStructure)digits[3]) << PyLong_SHIFT) | (MatStructure)digits[2]) << PyLong_SHIFT) | (MatStructure)digits[1]) << PyLong_SHIFT) | (MatStructure)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(MatStructure) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(MatStructure, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(MatStructure) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(MatStructure, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            MatStructure val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (MatStructure) -1;
        }
    } else {
        MatStructure val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (MatStructure) -1;
        val = __Pyx_PyInt_As_MatStructure(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to MatStructure");
    return (MatStructure) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to MatStructure");
    return (MatStructure) -1;
}

/* CIntFromPy */
static CYTHON_INLINE EPSConvergedReason __Pyx_PyInt_As_EPSConvergedReason(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSConvergedReason neg_one = (EPSConvergedReason) -1, const_zero = (EPSConvergedReason) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(EPSConvergedReason) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(EPSConvergedReason, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (EPSConvergedReason) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSConvergedReason) 0;
                case  1: __PYX_VERIFY_RETURN_INT(EPSConvergedReason, digit, digits[0])
                case 2:
                    if (8 * sizeof(EPSConvergedReason) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConvergedReason, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConvergedReason) >= 2 * PyLong_SHIFT) {
                            return (EPSConvergedReason) (((((EPSConvergedReason)digits[1]) << PyLong_SHIFT) | (EPSConvergedReason)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSConvergedReason) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConvergedReason, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConvergedReason) >= 3 * PyLong_SHIFT) {
                            return (EPSConvergedReason) (((((((EPSConvergedReason)digits[2]) << PyLong_SHIFT) | (EPSConvergedReason)digits[1]) << PyLong_SHIFT) | (EPSConvergedReason)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSConvergedReason) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConvergedReason, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConvergedReason) >= 4 * PyLong_SHIFT) {
                            return (EPSConvergedReason) (((((((((EPSConvergedReason)digits[3]) << PyLong_SHIFT) | (EPSConvergedReason)digits[2]) << PyLong_SHIFT) | (EPSConvergedReason)digits[1]) << PyLong_SHIFT) | (EPSConvergedReason)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (EPSConvergedReason) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(EPSConvergedReason) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSConvergedReason, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSConvergedReason) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSConvergedReason, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSConvergedReason) 0;
                case -1: __PYX_VERIFY_RETURN_INT(EPSConvergedReason, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(EPSConvergedReason,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(EPSConvergedReason) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConvergedReason, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConvergedReason) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSConvergedReason) (((EPSConvergedReason)-1)*(((((EPSConvergedReason)digits[1]) << PyLong_SHIFT) | (EPSConvergedReason)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(EPSConvergedReason) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConvergedReason, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConvergedReason) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSConvergedReason) ((((((EPSConvergedReason)digits[1]) << PyLong_SHIFT) | (EPSConvergedReason)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(EPSConvergedReason) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConvergedReason, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConvergedReason) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSConvergedReason) (((EPSConvergedReason)-1)*(((((((EPSConvergedReason)digits[2]) << PyLong_SHIFT) | (EPSConvergedReason)digits[1]) << PyLong_SHIFT) | (EPSConvergedReason)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSConvergedReason) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConvergedReason, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConvergedReason) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSConvergedReason) ((((((((EPSConvergedReason)digits[2]) << PyLong_SHIFT) | (EPSConvergedReason)digits[1]) << PyLong_SHIFT) | (EPSConvergedReason)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(EPSConvergedReason) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConvergedReason, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConvergedReason) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSConvergedReason) (((EPSConvergedReason)-1)*(((((((((EPSConvergedReason)digits[3]) << PyLong_SHIFT) | (EPSConvergedReason)digits[2]) << PyLong_SHIFT) | (EPSConvergedReason)digits[1]) << PyLong_SHIFT) | (EPSConvergedReason)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSConvergedReason) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConvergedReason, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConvergedReason) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSConvergedReason) ((((((((((EPSConvergedReason)digits[3]) << PyLong_SHIFT) | (EPSConvergedReason)digits[2]) << PyLong_SHIFT) | (EPSConvergedReason)digits[1]) << PyLong_SHIFT) | (EPSConvergedReason)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(EPSConvergedReason) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSConvergedReason, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSConvergedReason) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSConvergedReason, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            EPSConvergedReason val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (EPSConvergedReason) -1;
        }
    } else {
        EPSConvergedReason val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (EPSConvergedReason) -1;
        val = __Pyx_PyInt_As_EPSConvergedReason(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to EPSConvergedReason");
    return (EPSConvergedReason) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to EPSConvergedReason");
    return (EPSConvergedReason) -1;
}

/* CIntFromPy */
static CYTHON_INLINE SVDConvergedReason __Pyx_PyInt_As_SVDConvergedReason(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const SVDConvergedReason neg_one = (SVDConvergedReason) -1, const_zero = (SVDConvergedReason) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(SVDConvergedReason) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(SVDConvergedReason, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (SVDConvergedReason) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (SVDConvergedReason) 0;
                case  1: __PYX_VERIFY_RETURN_INT(SVDConvergedReason, digit, digits[0])
                case 2:
                    if (8 * sizeof(SVDConvergedReason) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConvergedReason, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConvergedReason) >= 2 * PyLong_SHIFT) {
                            return (SVDConvergedReason) (((((SVDConvergedReason)digits[1]) << PyLong_SHIFT) | (SVDConvergedReason)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(SVDConvergedReason) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConvergedReason, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConvergedReason) >= 3 * PyLong_SHIFT) {
                            return (SVDConvergedReason) (((((((SVDConvergedReason)digits[2]) << PyLong_SHIFT) | (SVDConvergedReason)digits[1]) << PyLong_SHIFT) | (SVDConvergedReason)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(SVDConvergedReason) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConvergedReason, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConvergedReason) >= 4 * PyLong_SHIFT) {
                            return (SVDConvergedReason) (((((((((SVDConvergedReason)digits[3]) << PyLong_SHIFT) | (SVDConvergedReason)digits[2]) << PyLong_SHIFT) | (SVDConvergedReason)digits[1]) << PyLong_SHIFT) | (SVDConvergedReason)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (SVDConvergedReason) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(SVDConvergedReason) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDConvergedReason, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(SVDConvergedReason) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDConvergedReason, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (SVDConvergedReason) 0;
                case -1: __PYX_VERIFY_RETURN_INT(SVDConvergedReason, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(SVDConvergedReason,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(SVDConvergedReason) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConvergedReason, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConvergedReason) - 1 > 2 * PyLong_SHIFT) {
                            return (SVDConvergedReason) (((SVDConvergedReason)-1)*(((((SVDConvergedReason)digits[1]) << PyLong_SHIFT) | (SVDConvergedReason)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(SVDConvergedReason) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConvergedReason, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConvergedReason) - 1 > 2 * PyLong_SHIFT) {
                            return (SVDConvergedReason) ((((((SVDConvergedReason)digits[1]) << PyLong_SHIFT) | (SVDConvergedReason)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(SVDConvergedReason) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConvergedReason, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConvergedReason) - 1 > 3 * PyLong_SHIFT) {
                            return (SVDConvergedReason) (((SVDConvergedReason)-1)*(((((((SVDConvergedReason)digits[2]) << PyLong_SHIFT) | (SVDConvergedReason)digits[1]) << PyLong_SHIFT) | (SVDConvergedReason)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(SVDConvergedReason) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConvergedReason, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConvergedReason) - 1 > 3 * PyLong_SHIFT) {
                            return (SVDConvergedReason) ((((((((SVDConvergedReason)digits[2]) << PyLong_SHIFT) | (SVDConvergedReason)digits[1]) << PyLong_SHIFT) | (SVDConvergedReason)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(SVDConvergedReason) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConvergedReason, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConvergedReason) - 1 > 4 * PyLong_SHIFT) {
                            return (SVDConvergedReason) (((SVDConvergedReason)-1)*(((((((((SVDConvergedReason)digits[3]) << PyLong_SHIFT) | (SVDConvergedReason)digits[2]) << PyLong_SHIFT) | (SVDConvergedReason)digits[1]) << PyLong_SHIFT) | (SVDConvergedReason)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(SVDConvergedReason) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConvergedReason, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConvergedReason) - 1 > 4 * PyLong_SHIFT) {
                            return (SVDConvergedReason) ((((((((((SVDConvergedReason)digits[3]) << PyLong_SHIFT) | (SVDConvergedReason)digits[2]) << PyLong_SHIFT) | (SVDConvergedReason)digits[1]) << PyLong_SHIFT) | (SVDConvergedReason)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(SVDConvergedReason) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDConvergedReason, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(SVDConvergedReason) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDConvergedReason, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            SVDConvergedReason val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (SVDConvergedReason) -1;
        }
    } else {
        SVDConvergedReason val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (SVDConvergedReason) -1;
        val = __Pyx_PyInt_As_SVDConvergedReason(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to SVDConvergedReason");
    return (SVDConvergedReason) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to SVDConvergedReason");
    return (SVDConvergedReason) -1;
}

/* CIntFromPy */
static CYTHON_INLINE PEPConvergedReason __Pyx_PyInt_As_PEPConvergedReason(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPConvergedReason neg_one = (PEPConvergedReason) -1, const_zero = (PEPConvergedReason) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(PEPConvergedReason) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(PEPConvergedReason, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (PEPConvergedReason) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPConvergedReason) 0;
                case  1: __PYX_VERIFY_RETURN_INT(PEPConvergedReason, digit, digits[0])
                case 2:
                    if (8 * sizeof(PEPConvergedReason) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConvergedReason, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConvergedReason) >= 2 * PyLong_SHIFT) {
                            return (PEPConvergedReason) (((((PEPConvergedReason)digits[1]) << PyLong_SHIFT) | (PEPConvergedReason)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPConvergedReason) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConvergedReason, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConvergedReason) >= 3 * PyLong_SHIFT) {
                            return (PEPConvergedReason) (((((((PEPConvergedReason)digits[2]) << PyLong_SHIFT) | (PEPConvergedReason)digits[1]) << PyLong_SHIFT) | (PEPConvergedReason)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPConvergedReason) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConvergedReason, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConvergedReason) >= 4 * PyLong_SHIFT) {
                            return (PEPConvergedReason) (((((((((PEPConvergedReason)digits[3]) << PyLong_SHIFT) | (PEPConvergedReason)digits[2]) << PyLong_SHIFT) | (PEPConvergedReason)digits[1]) << PyLong_SHIFT) | (PEPConvergedReason)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (PEPConvergedReason) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(PEPConvergedReason) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPConvergedReason, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPConvergedReason) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPConvergedReason, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPConvergedReason) 0;
                case -1: __PYX_VERIFY_RETURN_INT(PEPConvergedReason, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(PEPConvergedReason,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(PEPConvergedReason) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConvergedReason, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConvergedReason) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPConvergedReason) (((PEPConvergedReason)-1)*(((((PEPConvergedReason)digits[1]) << PyLong_SHIFT) | (PEPConvergedReason)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(PEPConvergedReason) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConvergedReason, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConvergedReason) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPConvergedReason) ((((((PEPConvergedReason)digits[1]) << PyLong_SHIFT) | (PEPConvergedReason)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(PEPConvergedReason) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConvergedReason, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConvergedReason) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPConvergedReason) (((PEPConvergedReason)-1)*(((((((PEPConvergedReason)digits[2]) << PyLong_SHIFT) | (PEPConvergedReason)digits[1]) << PyLong_SHIFT) | (PEPConvergedReason)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPConvergedReason) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConvergedReason, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConvergedReason) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPConvergedReason) ((((((((PEPConvergedReason)digits[2]) << PyLong_SHIFT) | (PEPConvergedReason)digits[1]) << PyLong_SHIFT) | (PEPConvergedReason)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(PEPConvergedReason) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConvergedReason, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConvergedReason) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPConvergedReason) (((PEPConvergedReason)-1)*(((((((((PEPConvergedReason)digits[3]) << PyLong_SHIFT) | (PEPConvergedReason)digits[2]) << PyLong_SHIFT) | (PEPConvergedReason)digits[1]) << PyLong_SHIFT) | (PEPConvergedReason)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPConvergedReason) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConvergedReason, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConvergedReason) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPConvergedReason) ((((((((((PEPConvergedReason)digits[3]) << PyLong_SHIFT) | (PEPConvergedReason)digits[2]) << PyLong_SHIFT) | (PEPConvergedReason)digits[1]) << PyLong_SHIFT) | (PEPConvergedReason)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(PEPConvergedReason) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPConvergedReason, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPConvergedReason) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPConvergedReason, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            PEPConvergedReason val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (PEPConvergedReason) -1;
        }
    } else {
        PEPConvergedReason val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (PEPConvergedReason) -1;
        val = __Pyx_PyInt_As_PEPConvergedReason(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to PEPConvergedReason");
    return (PEPConvergedReason) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to PEPConvergedReason");
    return (PEPConvergedReason) -1;
}

/* CIntFromPy */
static CYTHON_INLINE NEPConvergedReason __Pyx_PyInt_As_NEPConvergedReason(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPConvergedReason neg_one = (NEPConvergedReason) -1, const_zero = (NEPConvergedReason) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(NEPConvergedReason) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(NEPConvergedReason, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (NEPConvergedReason) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPConvergedReason) 0;
                case  1: __PYX_VERIFY_RETURN_INT(NEPConvergedReason, digit, digits[0])
                case 2:
                    if (8 * sizeof(NEPConvergedReason) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConvergedReason, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConvergedReason) >= 2 * PyLong_SHIFT) {
                            return (NEPConvergedReason) (((((NEPConvergedReason)digits[1]) << PyLong_SHIFT) | (NEPConvergedReason)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPConvergedReason) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConvergedReason, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConvergedReason) >= 3 * PyLong_SHIFT) {
                            return (NEPConvergedReason) (((((((NEPConvergedReason)digits[2]) << PyLong_SHIFT) | (NEPConvergedReason)digits[1]) << PyLong_SHIFT) | (NEPConvergedReason)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPConvergedReason) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConvergedReason, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConvergedReason) >= 4 * PyLong_SHIFT) {
                            return (NEPConvergedReason) (((((((((NEPConvergedReason)digits[3]) << PyLong_SHIFT) | (NEPConvergedReason)digits[2]) << PyLong_SHIFT) | (NEPConvergedReason)digits[1]) << PyLong_SHIFT) | (NEPConvergedReason)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (NEPConvergedReason) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(NEPConvergedReason) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPConvergedReason, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPConvergedReason) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPConvergedReason, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPConvergedReason) 0;
                case -1: __PYX_VERIFY_RETURN_INT(NEPConvergedReason, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(NEPConvergedReason,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(NEPConvergedReason) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConvergedReason, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConvergedReason) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPConvergedReason) (((NEPConvergedReason)-1)*(((((NEPConvergedReason)digits[1]) << PyLong_SHIFT) | (NEPConvergedReason)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(NEPConvergedReason) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConvergedReason, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConvergedReason) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPConvergedReason) ((((((NEPConvergedReason)digits[1]) << PyLong_SHIFT) | (NEPConvergedReason)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(NEPConvergedReason) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConvergedReason, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConvergedReason) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPConvergedReason) (((NEPConvergedReason)-1)*(((((((NEPConvergedReason)digits[2]) << PyLong_SHIFT) | (NEPConvergedReason)digits[1]) << PyLong_SHIFT) | (NEPConvergedReason)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPConvergedReason) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConvergedReason, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConvergedReason) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPConvergedReason) ((((((((NEPConvergedReason)digits[2]) << PyLong_SHIFT) | (NEPConvergedReason)digits[1]) << PyLong_SHIFT) | (NEPConvergedReason)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(NEPConvergedReason) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConvergedReason, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConvergedReason) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPConvergedReason) (((NEPConvergedReason)-1)*(((((((((NEPConvergedReason)digits[3]) << PyLong_SHIFT) | (NEPConvergedReason)digits[2]) << PyLong_SHIFT) | (NEPConvergedReason)digits[1]) << PyLong_SHIFT) | (NEPConvergedReason)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPConvergedReason) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConvergedReason, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConvergedReason) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPConvergedReason) ((((((((((NEPConvergedReason)digits[3]) << PyLong_SHIFT) | (NEPConvergedReason)digits[2]) << PyLong_SHIFT) | (NEPConvergedReason)digits[1]) << PyLong_SHIFT) | (NEPConvergedReason)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(NEPConvergedReason) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPConvergedReason, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPConvergedReason) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPConvergedReason, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            NEPConvergedReason val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (NEPConvergedReason) -1;
        }
    } else {
        NEPConvergedReason val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (NEPConvergedReason) -1;
        val = __Pyx_PyInt_As_NEPConvergedReason(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to NEPConvergedReason");
    return (NEPConvergedReason) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to NEPConvergedReason");
    return (NEPConvergedReason) -1;
}

/* CIntFromPy */
static CYTHON_INLINE STMatMode __Pyx_PyInt_As_STMatMode(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const STMatMode neg_one = (STMatMode) -1, const_zero = (STMatMode) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(STMatMode) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(STMatMode, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (STMatMode) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (STMatMode) 0;
                case  1: __PYX_VERIFY_RETURN_INT(STMatMode, digit, digits[0])
                case 2:
                    if (8 * sizeof(STMatMode) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(STMatMode, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(STMatMode) >= 2 * PyLong_SHIFT) {
                            return (STMatMode) (((((STMatMode)digits[1]) << PyLong_SHIFT) | (STMatMode)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(STMatMode) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(STMatMode, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(STMatMode) >= 3 * PyLong_SHIFT) {
                            return (STMatMode) (((((((STMatMode)digits[2]) << PyLong_SHIFT) | (STMatMode)digits[1]) << PyLong_SHIFT) | (STMatMode)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(STMatMode) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(STMatMode, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(STMatMode) >= 4 * PyLong_SHIFT) {
                            return (STMatMode) (((((((((STMatMode)digits[3]) << PyLong_SHIFT) | (STMatMode)digits[2]) << PyLong_SHIFT) | (STMatMode)digits[1]) << PyLong_SHIFT) | (STMatMode)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (STMatMode) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(STMatMode) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(STMatMode, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(STMatMode) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(STMatMode, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (STMatMode) 0;
                case -1: __PYX_VERIFY_RETURN_INT(STMatMode, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(STMatMode,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(STMatMode) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(STMatMode, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(STMatMode) - 1 > 2 * PyLong_SHIFT) {
                            return (STMatMode) (((STMatMode)-1)*(((((STMatMode)digits[1]) << PyLong_SHIFT) | (STMatMode)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(STMatMode) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(STMatMode, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(STMatMode) - 1 > 2 * PyLong_SHIFT) {
                            return (STMatMode) ((((((STMatMode)digits[1]) << PyLong_SHIFT) | (STMatMode)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(STMatMode) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(STMatMode, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(STMatMode) - 1 > 3 * PyLong_SHIFT) {
                            return (STMatMode) (((STMatMode)-1)*(((((((STMatMode)digits[2]) << PyLong_SHIFT) | (STMatMode)digits[1]) << PyLong_SHIFT) | (STMatMode)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(STMatMode) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(STMatMode, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(STMatMode) - 1 > 3 * PyLong_SHIFT) {
                            return (STMatMode) ((((((((STMatMode)digits[2]) << PyLong_SHIFT) | (STMatMode)digits[1]) << PyLong_SHIFT) | (STMatMode)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(STMatMode) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(STMatMode, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(STMatMode) - 1 > 4 * PyLong_SHIFT) {
                            return (STMatMode) (((STMatMode)-1)*(((((((((STMatMode)digits[3]) << PyLong_SHIFT) | (STMatMode)digits[2]) << PyLong_SHIFT) | (STMatMode)digits[1]) << PyLong_SHIFT) | (STMatMode)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(STMatMode) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(STMatMode, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(STMatMode) - 1 > 4 * PyLong_SHIFT) {
                            return (STMatMode) ((((((((((STMatMode)digits[3]) << PyLong_SHIFT) | (STMatMode)digits[2]) << PyLong_SHIFT) | (STMatMode)digits[1]) << PyLong_SHIFT) | (STMatMode)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(STMatMode) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(STMatMode, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(STMatMode) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(STMatMode, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            STMatMode val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (STMatMode) -1;
        }
    } else {
        STMatMode val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (STMatMode) -1;
        val = __Pyx_PyInt_As_STMatMode(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to STMatMode");
    return (STMatMode) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to STMatMode");
    return (STMatMode) -1;
}

/* CIntToPy */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MatStructure(MatStructure value) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const MatStructure neg_one = (MatStructure) -1, const_zero = (MatStructure) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(MatStructure) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(MatStructure) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(MatStructure) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
#endif
        }
    } else {
        if (sizeof(MatStructure) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
#ifdef HAVE_LONG_LONG
        } else if (sizeof(MatStructure) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
#endif
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(MatStructure),
                                     little, !is_unsigned);
    }
}

/* CIntFromPy */
static CYTHON_INLINE BVOrthogType __Pyx_PyInt_As_BVOrthogType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const BVOrthogType neg_one = (BVOrthogType) -1, const_zero = (BVOrthogType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(BVOrthogType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(BVOrthogType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (BVOrthogType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (BVOrthogType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(BVOrthogType, digit, digits[0])
                case 2:
                    if (8 * sizeof(BVOrthogType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogType) >= 2 * PyLong_SHIFT) {
                            return (BVOrthogType) (((((BVOrthogType)digits[1]) << PyLong_SHIFT) | (BVOrthogType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(BVOrthogType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogType) >= 3 * PyLong_SHIFT) {
                            return (BVOrthogType) (((((((BVOrthogType)digits[2]) << PyLong_SHIFT) | (BVOrthogType)digits[1]) << PyLong_SHIFT) | (BVOrthogType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(BVOrthogType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogType) >= 4 * PyLong_SHIFT) {
                            return (BVOrthogType) (((((((((BVOrthogType)digits[3]) << PyLong_SHIFT) | (BVOrthogType)digits[2]) << PyLong_SHIFT) | (BVOrthogType)digits[1]) << PyLong_SHIFT) | (BVOrthogType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (BVOrthogType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(BVOrthogType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVOrthogType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(BVOrthogType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVOrthogType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (BVOrthogType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(BVOrthogType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(BVOrthogType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(BVOrthogType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogType) - 1 > 2 * PyLong_SHIFT) {
                            return (BVOrthogType) (((BVOrthogType)-1)*(((((BVOrthogType)digits[1]) << PyLong_SHIFT) | (BVOrthogType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(BVOrthogType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogType) - 1 > 2 * PyLong_SHIFT) {
                            return (BVOrthogType) ((((((BVOrthogType)digits[1]) << PyLong_SHIFT) | (BVOrthogType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(BVOrthogType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogType) - 1 > 3 * PyLong_SHIFT) {
                            return (BVOrthogType) (((BVOrthogType)-1)*(((((((BVOrthogType)digits[2]) << PyLong_SHIFT) | (BVOrthogType)digits[1]) << PyLong_SHIFT) | (BVOrthogType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(BVOrthogType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogType) - 1 > 3 * PyLong_SHIFT) {
                            return (BVOrthogType) ((((((((BVOrthogType)digits[2]) << PyLong_SHIFT) | (BVOrthogType)digits[1]) << PyLong_SHIFT) | (BVOrthogType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(BVOrthogType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogType) - 1 > 4 * PyLong_SHIFT) {
                            return (BVOrthogType) (((BVOrthogType)-1)*(((((((((BVOrthogType)digits[3]) << PyLong_SHIFT) | (BVOrthogType)digits[2]) << PyLong_SHIFT) | (BVOrthogType)digits[1]) << PyLong_SHIFT) | (BVOrthogType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(BVOrthogType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogType) - 1 > 4 * PyLong_SHIFT) {
                            return (BVOrthogType) ((((((((((BVOrthogType)digits[3]) << PyLong_SHIFT) | (BVOrthogType)digits[2]) << PyLong_SHIFT) | (BVOrthogType)digits[1]) << PyLong_SHIFT) | (BVOrthogType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(BVOrthogType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVOrthogType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(BVOrthogType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVOrthogType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            BVOrthogType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (BVOrthogType) -1;
        }
    } else {
        BVOrthogType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (BVOrthogType) -1;
        val = __Pyx_PyInt_As_BVOrthogType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to BVOrthogType");
    return (BVOrthogType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to BVOrthogType");
    return (BVOrthogType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE BVOrthogRefineType __Pyx_PyInt_As_BVOrthogRefineType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const BVOrthogRefineType neg_one = (BVOrthogRefineType) -1, const_zero = (BVOrthogRefineType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(BVOrthogRefineType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(BVOrthogRefineType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (BVOrthogRefineType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (BVOrthogRefineType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(BVOrthogRefineType, digit, digits[0])
                case 2:
                    if (8 * sizeof(BVOrthogRefineType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogRefineType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogRefineType) >= 2 * PyLong_SHIFT) {
                            return (BVOrthogRefineType) (((((BVOrthogRefineType)digits[1]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(BVOrthogRefineType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogRefineType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogRefineType) >= 3 * PyLong_SHIFT) {
                            return (BVOrthogRefineType) (((((((BVOrthogRefineType)digits[2]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[1]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(BVOrthogRefineType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogRefineType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogRefineType) >= 4 * PyLong_SHIFT) {
                            return (BVOrthogRefineType) (((((((((BVOrthogRefineType)digits[3]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[2]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[1]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (BVOrthogRefineType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(BVOrthogRefineType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVOrthogRefineType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(BVOrthogRefineType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVOrthogRefineType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (BVOrthogRefineType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(BVOrthogRefineType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(BVOrthogRefineType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(BVOrthogRefineType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogRefineType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogRefineType) - 1 > 2 * PyLong_SHIFT) {
                            return (BVOrthogRefineType) (((BVOrthogRefineType)-1)*(((((BVOrthogRefineType)digits[1]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(BVOrthogRefineType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogRefineType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogRefineType) - 1 > 2 * PyLong_SHIFT) {
                            return (BVOrthogRefineType) ((((((BVOrthogRefineType)digits[1]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(BVOrthogRefineType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogRefineType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogRefineType) - 1 > 3 * PyLong_SHIFT) {
                            return (BVOrthogRefineType) (((BVOrthogRefineType)-1)*(((((((BVOrthogRefineType)digits[2]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[1]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(BVOrthogRefineType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogRefineType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogRefineType) - 1 > 3 * PyLong_SHIFT) {
                            return (BVOrthogRefineType) ((((((((BVOrthogRefineType)digits[2]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[1]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(BVOrthogRefineType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogRefineType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogRefineType) - 1 > 4 * PyLong_SHIFT) {
                            return (BVOrthogRefineType) (((BVOrthogRefineType)-1)*(((((((((BVOrthogRefineType)digits[3]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[2]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[1]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(BVOrthogRefineType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogRefineType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogRefineType) - 1 > 4 * PyLong_SHIFT) {
                            return (BVOrthogRefineType) ((((((((((BVOrthogRefineType)digits[3]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[2]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[1]) << PyLong_SHIFT) | (BVOrthogRefineType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(BVOrthogRefineType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVOrthogRefineType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(BVOrthogRefineType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVOrthogRefineType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            BVOrthogRefineType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (BVOrthogRefineType) -1;
        }
    } else {
        BVOrthogRefineType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (BVOrthogRefineType) -1;
        val = __Pyx_PyInt_As_BVOrthogRefineType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to BVOrthogRefineType");
    return (BVOrthogRefineType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to BVOrthogRefineType");
    return (BVOrthogRefineType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE BVOrthogBlockType __Pyx_PyInt_As_BVOrthogBlockType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const BVOrthogBlockType neg_one = (BVOrthogBlockType) -1, const_zero = (BVOrthogBlockType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(BVOrthogBlockType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(BVOrthogBlockType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (BVOrthogBlockType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (BVOrthogBlockType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(BVOrthogBlockType, digit, digits[0])
                case 2:
                    if (8 * sizeof(BVOrthogBlockType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogBlockType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogBlockType) >= 2 * PyLong_SHIFT) {
                            return (BVOrthogBlockType) (((((BVOrthogBlockType)digits[1]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(BVOrthogBlockType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogBlockType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogBlockType) >= 3 * PyLong_SHIFT) {
                            return (BVOrthogBlockType) (((((((BVOrthogBlockType)digits[2]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[1]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(BVOrthogBlockType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogBlockType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogBlockType) >= 4 * PyLong_SHIFT) {
                            return (BVOrthogBlockType) (((((((((BVOrthogBlockType)digits[3]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[2]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[1]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (BVOrthogBlockType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(BVOrthogBlockType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVOrthogBlockType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(BVOrthogBlockType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVOrthogBlockType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (BVOrthogBlockType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(BVOrthogBlockType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(BVOrthogBlockType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(BVOrthogBlockType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogBlockType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogBlockType) - 1 > 2 * PyLong_SHIFT) {
                            return (BVOrthogBlockType) (((BVOrthogBlockType)-1)*(((((BVOrthogBlockType)digits[1]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(BVOrthogBlockType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogBlockType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogBlockType) - 1 > 2 * PyLong_SHIFT) {
                            return (BVOrthogBlockType) ((((((BVOrthogBlockType)digits[1]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(BVOrthogBlockType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogBlockType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogBlockType) - 1 > 3 * PyLong_SHIFT) {
                            return (BVOrthogBlockType) (((BVOrthogBlockType)-1)*(((((((BVOrthogBlockType)digits[2]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[1]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(BVOrthogBlockType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogBlockType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogBlockType) - 1 > 3 * PyLong_SHIFT) {
                            return (BVOrthogBlockType) ((((((((BVOrthogBlockType)digits[2]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[1]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(BVOrthogBlockType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogBlockType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogBlockType) - 1 > 4 * PyLong_SHIFT) {
                            return (BVOrthogBlockType) (((BVOrthogBlockType)-1)*(((((((((BVOrthogBlockType)digits[3]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[2]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[1]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(BVOrthogBlockType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVOrthogBlockType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVOrthogBlockType) - 1 > 4 * PyLong_SHIFT) {
                            return (BVOrthogBlockType) ((((((((((BVOrthogBlockType)digits[3]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[2]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[1]) << PyLong_SHIFT) | (BVOrthogBlockType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(BVOrthogBlockType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVOrthogBlockType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(BVOrthogBlockType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVOrthogBlockType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            BVOrthogBlockType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (BVOrthogBlockType) -1;
        }
    } else {
        BVOrthogBlockType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (BVOrthogBlockType) -1;
        val = __Pyx_PyInt_As_BVOrthogBlockType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to BVOrthogBlockType");
    return (BVOrthogBlockType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to BVOrthogBlockType");
    return (BVOrthogBlockType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE BVMatMultType __Pyx_PyInt_As_BVMatMultType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const BVMatMultType neg_one = (BVMatMultType) -1, const_zero = (BVMatMultType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(BVMatMultType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(BVMatMultType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (BVMatMultType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (BVMatMultType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(BVMatMultType, digit, digits[0])
                case 2:
                    if (8 * sizeof(BVMatMultType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVMatMultType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVMatMultType) >= 2 * PyLong_SHIFT) {
                            return (BVMatMultType) (((((BVMatMultType)digits[1]) << PyLong_SHIFT) | (BVMatMultType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(BVMatMultType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVMatMultType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVMatMultType) >= 3 * PyLong_SHIFT) {
                            return (BVMatMultType) (((((((BVMatMultType)digits[2]) << PyLong_SHIFT) | (BVMatMultType)digits[1]) << PyLong_SHIFT) | (BVMatMultType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(BVMatMultType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVMatMultType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVMatMultType) >= 4 * PyLong_SHIFT) {
                            return (BVMatMultType) (((((((((BVMatMultType)digits[3]) << PyLong_SHIFT) | (BVMatMultType)digits[2]) << PyLong_SHIFT) | (BVMatMultType)digits[1]) << PyLong_SHIFT) | (BVMatMultType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (BVMatMultType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(BVMatMultType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVMatMultType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(BVMatMultType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVMatMultType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (BVMatMultType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(BVMatMultType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(BVMatMultType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(BVMatMultType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVMatMultType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVMatMultType) - 1 > 2 * PyLong_SHIFT) {
                            return (BVMatMultType) (((BVMatMultType)-1)*(((((BVMatMultType)digits[1]) << PyLong_SHIFT) | (BVMatMultType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(BVMatMultType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVMatMultType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVMatMultType) - 1 > 2 * PyLong_SHIFT) {
                            return (BVMatMultType) ((((((BVMatMultType)digits[1]) << PyLong_SHIFT) | (BVMatMultType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(BVMatMultType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVMatMultType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVMatMultType) - 1 > 3 * PyLong_SHIFT) {
                            return (BVMatMultType) (((BVMatMultType)-1)*(((((((BVMatMultType)digits[2]) << PyLong_SHIFT) | (BVMatMultType)digits[1]) << PyLong_SHIFT) | (BVMatMultType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(BVMatMultType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVMatMultType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVMatMultType) - 1 > 3 * PyLong_SHIFT) {
                            return (BVMatMultType) ((((((((BVMatMultType)digits[2]) << PyLong_SHIFT) | (BVMatMultType)digits[1]) << PyLong_SHIFT) | (BVMatMultType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(BVMatMultType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVMatMultType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVMatMultType) - 1 > 4 * PyLong_SHIFT) {
                            return (BVMatMultType) (((BVMatMultType)-1)*(((((((((BVMatMultType)digits[3]) << PyLong_SHIFT) | (BVMatMultType)digits[2]) << PyLong_SHIFT) | (BVMatMultType)digits[1]) << PyLong_SHIFT) | (BVMatMultType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(BVMatMultType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(BVMatMultType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(BVMatMultType) - 1 > 4 * PyLong_SHIFT) {
                            return (BVMatMultType) ((((((((((BVMatMultType)digits[3]) << PyLong_SHIFT) | (BVMatMultType)digits[2]) << PyLong_SHIFT) | (BVMatMultType)digits[1]) << PyLong_SHIFT) | (BVMatMultType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(BVMatMultType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVMatMultType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(BVMatMultType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(BVMatMultType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            BVMatMultType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (BVMatMultType) -1;
        }
    } else {
        BVMatMultType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (BVMatMultType) -1;
        val = __Pyx_PyInt_As_BVMatMultType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to BVMatMultType");
    return (BVMatMultType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to BVMatMultType");
    return (BVMatMultType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const size_t neg_one = (size_t) -1, const_zero = (size_t) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(size_t) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (size_t) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (size_t) 0;
                case  1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0])
                case 2:
                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) {
                            return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) {
                            return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) {
                            return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (size_t) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(size_t) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (size_t) 0;
                case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(size_t,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
                            return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
                            return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
                            return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
                            return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
                            return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
                            return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(size_t) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            size_t val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (size_t) -1;
        }
    } else {
        size_t val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (size_t) -1;
        val = __Pyx_PyInt_As_size_t(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to size_t");
    return (size_t) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to size_t");
    return (size_t) -1;
}

/* CIntFromPy */
static CYTHON_INLINE NormType __Pyx_PyInt_As_NormType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NormType neg_one = (NormType) -1, const_zero = (NormType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(NormType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(NormType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (NormType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NormType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(NormType, digit, digits[0])
                case 2:
                    if (8 * sizeof(NormType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NormType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NormType) >= 2 * PyLong_SHIFT) {
                            return (NormType) (((((NormType)digits[1]) << PyLong_SHIFT) | (NormType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NormType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NormType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NormType) >= 3 * PyLong_SHIFT) {
                            return (NormType) (((((((NormType)digits[2]) << PyLong_SHIFT) | (NormType)digits[1]) << PyLong_SHIFT) | (NormType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NormType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NormType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NormType) >= 4 * PyLong_SHIFT) {
                            return (NormType) (((((((((NormType)digits[3]) << PyLong_SHIFT) | (NormType)digits[2]) << PyLong_SHIFT) | (NormType)digits[1]) << PyLong_SHIFT) | (NormType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (NormType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(NormType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NormType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NormType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NormType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NormType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(NormType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(NormType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(NormType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NormType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NormType) - 1 > 2 * PyLong_SHIFT) {
                            return (NormType) (((NormType)-1)*(((((NormType)digits[1]) << PyLong_SHIFT) | (NormType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(NormType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NormType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NormType) - 1 > 2 * PyLong_SHIFT) {
                            return (NormType) ((((((NormType)digits[1]) << PyLong_SHIFT) | (NormType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(NormType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NormType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NormType) - 1 > 3 * PyLong_SHIFT) {
                            return (NormType) (((NormType)-1)*(((((((NormType)digits[2]) << PyLong_SHIFT) | (NormType)digits[1]) << PyLong_SHIFT) | (NormType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NormType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NormType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NormType) - 1 > 3 * PyLong_SHIFT) {
                            return (NormType) ((((((((NormType)digits[2]) << PyLong_SHIFT) | (NormType)digits[1]) << PyLong_SHIFT) | (NormType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(NormType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NormType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NormType) - 1 > 4 * PyLong_SHIFT) {
                            return (NormType) (((NormType)-1)*(((((((((NormType)digits[3]) << PyLong_SHIFT) | (NormType)digits[2]) << PyLong_SHIFT) | (NormType)digits[1]) << PyLong_SHIFT) | (NormType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NormType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NormType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NormType) - 1 > 4 * PyLong_SHIFT) {
                            return (NormType) ((((((((((NormType)digits[3]) << PyLong_SHIFT) | (NormType)digits[2]) << PyLong_SHIFT) | (NormType)digits[1]) << PyLong_SHIFT) | (NormType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(NormType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NormType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NormType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NormType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            NormType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (NormType) -1;
        }
    } else {
        NormType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (NormType) -1;
        val = __Pyx_PyInt_As_NormType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to NormType");
    return (NormType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to NormType");
    return (NormType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE DSStateType __Pyx_PyInt_As_DSStateType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const DSStateType neg_one = (DSStateType) -1, const_zero = (DSStateType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(DSStateType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(DSStateType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (DSStateType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (DSStateType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(DSStateType, digit, digits[0])
                case 2:
                    if (8 * sizeof(DSStateType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSStateType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSStateType) >= 2 * PyLong_SHIFT) {
                            return (DSStateType) (((((DSStateType)digits[1]) << PyLong_SHIFT) | (DSStateType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(DSStateType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSStateType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSStateType) >= 3 * PyLong_SHIFT) {
                            return (DSStateType) (((((((DSStateType)digits[2]) << PyLong_SHIFT) | (DSStateType)digits[1]) << PyLong_SHIFT) | (DSStateType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(DSStateType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSStateType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSStateType) >= 4 * PyLong_SHIFT) {
                            return (DSStateType) (((((((((DSStateType)digits[3]) << PyLong_SHIFT) | (DSStateType)digits[2]) << PyLong_SHIFT) | (DSStateType)digits[1]) << PyLong_SHIFT) | (DSStateType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (DSStateType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(DSStateType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(DSStateType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(DSStateType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(DSStateType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (DSStateType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(DSStateType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(DSStateType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(DSStateType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSStateType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSStateType) - 1 > 2 * PyLong_SHIFT) {
                            return (DSStateType) (((DSStateType)-1)*(((((DSStateType)digits[1]) << PyLong_SHIFT) | (DSStateType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(DSStateType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSStateType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSStateType) - 1 > 2 * PyLong_SHIFT) {
                            return (DSStateType) ((((((DSStateType)digits[1]) << PyLong_SHIFT) | (DSStateType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(DSStateType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSStateType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSStateType) - 1 > 3 * PyLong_SHIFT) {
                            return (DSStateType) (((DSStateType)-1)*(((((((DSStateType)digits[2]) << PyLong_SHIFT) | (DSStateType)digits[1]) << PyLong_SHIFT) | (DSStateType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(DSStateType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSStateType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSStateType) - 1 > 3 * PyLong_SHIFT) {
                            return (DSStateType) ((((((((DSStateType)digits[2]) << PyLong_SHIFT) | (DSStateType)digits[1]) << PyLong_SHIFT) | (DSStateType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(DSStateType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSStateType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSStateType) - 1 > 4 * PyLong_SHIFT) {
                            return (DSStateType) (((DSStateType)-1)*(((((((((DSStateType)digits[3]) << PyLong_SHIFT) | (DSStateType)digits[2]) << PyLong_SHIFT) | (DSStateType)digits[1]) << PyLong_SHIFT) | (DSStateType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(DSStateType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSStateType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSStateType) - 1 > 4 * PyLong_SHIFT) {
                            return (DSStateType) ((((((((((DSStateType)digits[3]) << PyLong_SHIFT) | (DSStateType)digits[2]) << PyLong_SHIFT) | (DSStateType)digits[1]) << PyLong_SHIFT) | (DSStateType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(DSStateType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(DSStateType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(DSStateType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(DSStateType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            DSStateType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (DSStateType) -1;
        }
    } else {
        DSStateType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (DSStateType) -1;
        val = __Pyx_PyInt_As_DSStateType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to DSStateType");
    return (DSStateType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to DSStateType");
    return (DSStateType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE DSParallelType __Pyx_PyInt_As_DSParallelType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const DSParallelType neg_one = (DSParallelType) -1, const_zero = (DSParallelType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(DSParallelType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(DSParallelType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (DSParallelType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (DSParallelType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(DSParallelType, digit, digits[0])
                case 2:
                    if (8 * sizeof(DSParallelType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSParallelType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSParallelType) >= 2 * PyLong_SHIFT) {
                            return (DSParallelType) (((((DSParallelType)digits[1]) << PyLong_SHIFT) | (DSParallelType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(DSParallelType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSParallelType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSParallelType) >= 3 * PyLong_SHIFT) {
                            return (DSParallelType) (((((((DSParallelType)digits[2]) << PyLong_SHIFT) | (DSParallelType)digits[1]) << PyLong_SHIFT) | (DSParallelType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(DSParallelType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSParallelType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSParallelType) >= 4 * PyLong_SHIFT) {
                            return (DSParallelType) (((((((((DSParallelType)digits[3]) << PyLong_SHIFT) | (DSParallelType)digits[2]) << PyLong_SHIFT) | (DSParallelType)digits[1]) << PyLong_SHIFT) | (DSParallelType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (DSParallelType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(DSParallelType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(DSParallelType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(DSParallelType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(DSParallelType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (DSParallelType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(DSParallelType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(DSParallelType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(DSParallelType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSParallelType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSParallelType) - 1 > 2 * PyLong_SHIFT) {
                            return (DSParallelType) (((DSParallelType)-1)*(((((DSParallelType)digits[1]) << PyLong_SHIFT) | (DSParallelType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(DSParallelType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSParallelType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSParallelType) - 1 > 2 * PyLong_SHIFT) {
                            return (DSParallelType) ((((((DSParallelType)digits[1]) << PyLong_SHIFT) | (DSParallelType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(DSParallelType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSParallelType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSParallelType) - 1 > 3 * PyLong_SHIFT) {
                            return (DSParallelType) (((DSParallelType)-1)*(((((((DSParallelType)digits[2]) << PyLong_SHIFT) | (DSParallelType)digits[1]) << PyLong_SHIFT) | (DSParallelType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(DSParallelType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSParallelType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSParallelType) - 1 > 3 * PyLong_SHIFT) {
                            return (DSParallelType) ((((((((DSParallelType)digits[2]) << PyLong_SHIFT) | (DSParallelType)digits[1]) << PyLong_SHIFT) | (DSParallelType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(DSParallelType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSParallelType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSParallelType) - 1 > 4 * PyLong_SHIFT) {
                            return (DSParallelType) (((DSParallelType)-1)*(((((((((DSParallelType)digits[3]) << PyLong_SHIFT) | (DSParallelType)digits[2]) << PyLong_SHIFT) | (DSParallelType)digits[1]) << PyLong_SHIFT) | (DSParallelType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(DSParallelType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSParallelType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSParallelType) - 1 > 4 * PyLong_SHIFT) {
                            return (DSParallelType) ((((((((((DSParallelType)digits[3]) << PyLong_SHIFT) | (DSParallelType)digits[2]) << PyLong_SHIFT) | (DSParallelType)digits[1]) << PyLong_SHIFT) | (DSParallelType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(DSParallelType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(DSParallelType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(DSParallelType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(DSParallelType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            DSParallelType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (DSParallelType) -1;
        }
    } else {
        DSParallelType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (DSParallelType) -1;
        val = __Pyx_PyInt_As_DSParallelType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to DSParallelType");
    return (DSParallelType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to DSParallelType");
    return (DSParallelType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE DSMatType __Pyx_PyInt_As_DSMatType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const DSMatType neg_one = (DSMatType) -1, const_zero = (DSMatType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(DSMatType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(DSMatType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (DSMatType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (DSMatType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(DSMatType, digit, digits[0])
                case 2:
                    if (8 * sizeof(DSMatType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSMatType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSMatType) >= 2 * PyLong_SHIFT) {
                            return (DSMatType) (((((DSMatType)digits[1]) << PyLong_SHIFT) | (DSMatType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(DSMatType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSMatType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSMatType) >= 3 * PyLong_SHIFT) {
                            return (DSMatType) (((((((DSMatType)digits[2]) << PyLong_SHIFT) | (DSMatType)digits[1]) << PyLong_SHIFT) | (DSMatType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(DSMatType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSMatType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSMatType) >= 4 * PyLong_SHIFT) {
                            return (DSMatType) (((((((((DSMatType)digits[3]) << PyLong_SHIFT) | (DSMatType)digits[2]) << PyLong_SHIFT) | (DSMatType)digits[1]) << PyLong_SHIFT) | (DSMatType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (DSMatType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(DSMatType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(DSMatType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(DSMatType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(DSMatType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (DSMatType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(DSMatType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(DSMatType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(DSMatType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSMatType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSMatType) - 1 > 2 * PyLong_SHIFT) {
                            return (DSMatType) (((DSMatType)-1)*(((((DSMatType)digits[1]) << PyLong_SHIFT) | (DSMatType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(DSMatType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSMatType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSMatType) - 1 > 2 * PyLong_SHIFT) {
                            return (DSMatType) ((((((DSMatType)digits[1]) << PyLong_SHIFT) | (DSMatType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(DSMatType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSMatType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSMatType) - 1 > 3 * PyLong_SHIFT) {
                            return (DSMatType) (((DSMatType)-1)*(((((((DSMatType)digits[2]) << PyLong_SHIFT) | (DSMatType)digits[1]) << PyLong_SHIFT) | (DSMatType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(DSMatType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSMatType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSMatType) - 1 > 3 * PyLong_SHIFT) {
                            return (DSMatType) ((((((((DSMatType)digits[2]) << PyLong_SHIFT) | (DSMatType)digits[1]) << PyLong_SHIFT) | (DSMatType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(DSMatType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSMatType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSMatType) - 1 > 4 * PyLong_SHIFT) {
                            return (DSMatType) (((DSMatType)-1)*(((((((((DSMatType)digits[3]) << PyLong_SHIFT) | (DSMatType)digits[2]) << PyLong_SHIFT) | (DSMatType)digits[1]) << PyLong_SHIFT) | (DSMatType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(DSMatType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(DSMatType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(DSMatType) - 1 > 4 * PyLong_SHIFT) {
                            return (DSMatType) ((((((((((DSMatType)digits[3]) << PyLong_SHIFT) | (DSMatType)digits[2]) << PyLong_SHIFT) | (DSMatType)digits[1]) << PyLong_SHIFT) | (DSMatType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(DSMatType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(DSMatType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(DSMatType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(DSMatType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            DSMatType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (DSMatType) -1;
        }
    } else {
        DSMatType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (DSMatType) -1;
        val = __Pyx_PyInt_As_DSMatType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to DSMatType");
    return (DSMatType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to DSMatType");
    return (DSMatType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE FNParallelType __Pyx_PyInt_As_FNParallelType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const FNParallelType neg_one = (FNParallelType) -1, const_zero = (FNParallelType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(FNParallelType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(FNParallelType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (FNParallelType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (FNParallelType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(FNParallelType, digit, digits[0])
                case 2:
                    if (8 * sizeof(FNParallelType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNParallelType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNParallelType) >= 2 * PyLong_SHIFT) {
                            return (FNParallelType) (((((FNParallelType)digits[1]) << PyLong_SHIFT) | (FNParallelType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(FNParallelType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNParallelType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNParallelType) >= 3 * PyLong_SHIFT) {
                            return (FNParallelType) (((((((FNParallelType)digits[2]) << PyLong_SHIFT) | (FNParallelType)digits[1]) << PyLong_SHIFT) | (FNParallelType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(FNParallelType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNParallelType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNParallelType) >= 4 * PyLong_SHIFT) {
                            return (FNParallelType) (((((((((FNParallelType)digits[3]) << PyLong_SHIFT) | (FNParallelType)digits[2]) << PyLong_SHIFT) | (FNParallelType)digits[1]) << PyLong_SHIFT) | (FNParallelType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (FNParallelType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(FNParallelType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(FNParallelType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(FNParallelType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(FNParallelType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (FNParallelType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(FNParallelType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(FNParallelType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(FNParallelType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNParallelType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNParallelType) - 1 > 2 * PyLong_SHIFT) {
                            return (FNParallelType) (((FNParallelType)-1)*(((((FNParallelType)digits[1]) << PyLong_SHIFT) | (FNParallelType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(FNParallelType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNParallelType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNParallelType) - 1 > 2 * PyLong_SHIFT) {
                            return (FNParallelType) ((((((FNParallelType)digits[1]) << PyLong_SHIFT) | (FNParallelType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(FNParallelType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNParallelType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNParallelType) - 1 > 3 * PyLong_SHIFT) {
                            return (FNParallelType) (((FNParallelType)-1)*(((((((FNParallelType)digits[2]) << PyLong_SHIFT) | (FNParallelType)digits[1]) << PyLong_SHIFT) | (FNParallelType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(FNParallelType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNParallelType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNParallelType) - 1 > 3 * PyLong_SHIFT) {
                            return (FNParallelType) ((((((((FNParallelType)digits[2]) << PyLong_SHIFT) | (FNParallelType)digits[1]) << PyLong_SHIFT) | (FNParallelType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(FNParallelType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNParallelType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNParallelType) - 1 > 4 * PyLong_SHIFT) {
                            return (FNParallelType) (((FNParallelType)-1)*(((((((((FNParallelType)digits[3]) << PyLong_SHIFT) | (FNParallelType)digits[2]) << PyLong_SHIFT) | (FNParallelType)digits[1]) << PyLong_SHIFT) | (FNParallelType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(FNParallelType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNParallelType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNParallelType) - 1 > 4 * PyLong_SHIFT) {
                            return (FNParallelType) ((((((((((FNParallelType)digits[3]) << PyLong_SHIFT) | (FNParallelType)digits[2]) << PyLong_SHIFT) | (FNParallelType)digits[1]) << PyLong_SHIFT) | (FNParallelType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(FNParallelType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(FNParallelType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(FNParallelType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(FNParallelType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            FNParallelType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (FNParallelType) -1;
        }
    } else {
        FNParallelType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (FNParallelType) -1;
        val = __Pyx_PyInt_As_FNParallelType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to FNParallelType");
    return (FNParallelType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to FNParallelType");
    return (FNParallelType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE FNCombineType __Pyx_PyInt_As_FNCombineType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const FNCombineType neg_one = (FNCombineType) -1, const_zero = (FNCombineType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(FNCombineType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(FNCombineType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (FNCombineType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (FNCombineType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(FNCombineType, digit, digits[0])
                case 2:
                    if (8 * sizeof(FNCombineType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNCombineType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNCombineType) >= 2 * PyLong_SHIFT) {
                            return (FNCombineType) (((((FNCombineType)digits[1]) << PyLong_SHIFT) | (FNCombineType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(FNCombineType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNCombineType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNCombineType) >= 3 * PyLong_SHIFT) {
                            return (FNCombineType) (((((((FNCombineType)digits[2]) << PyLong_SHIFT) | (FNCombineType)digits[1]) << PyLong_SHIFT) | (FNCombineType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(FNCombineType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNCombineType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNCombineType) >= 4 * PyLong_SHIFT) {
                            return (FNCombineType) (((((((((FNCombineType)digits[3]) << PyLong_SHIFT) | (FNCombineType)digits[2]) << PyLong_SHIFT) | (FNCombineType)digits[1]) << PyLong_SHIFT) | (FNCombineType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (FNCombineType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(FNCombineType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(FNCombineType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(FNCombineType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(FNCombineType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (FNCombineType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(FNCombineType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(FNCombineType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(FNCombineType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNCombineType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNCombineType) - 1 > 2 * PyLong_SHIFT) {
                            return (FNCombineType) (((FNCombineType)-1)*(((((FNCombineType)digits[1]) << PyLong_SHIFT) | (FNCombineType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(FNCombineType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNCombineType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNCombineType) - 1 > 2 * PyLong_SHIFT) {
                            return (FNCombineType) ((((((FNCombineType)digits[1]) << PyLong_SHIFT) | (FNCombineType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(FNCombineType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNCombineType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNCombineType) - 1 > 3 * PyLong_SHIFT) {
                            return (FNCombineType) (((FNCombineType)-1)*(((((((FNCombineType)digits[2]) << PyLong_SHIFT) | (FNCombineType)digits[1]) << PyLong_SHIFT) | (FNCombineType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(FNCombineType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNCombineType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNCombineType) - 1 > 3 * PyLong_SHIFT) {
                            return (FNCombineType) ((((((((FNCombineType)digits[2]) << PyLong_SHIFT) | (FNCombineType)digits[1]) << PyLong_SHIFT) | (FNCombineType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(FNCombineType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNCombineType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNCombineType) - 1 > 4 * PyLong_SHIFT) {
                            return (FNCombineType) (((FNCombineType)-1)*(((((((((FNCombineType)digits[3]) << PyLong_SHIFT) | (FNCombineType)digits[2]) << PyLong_SHIFT) | (FNCombineType)digits[1]) << PyLong_SHIFT) | (FNCombineType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(FNCombineType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(FNCombineType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(FNCombineType) - 1 > 4 * PyLong_SHIFT) {
                            return (FNCombineType) ((((((((((FNCombineType)digits[3]) << PyLong_SHIFT) | (FNCombineType)digits[2]) << PyLong_SHIFT) | (FNCombineType)digits[1]) << PyLong_SHIFT) | (FNCombineType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(FNCombineType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(FNCombineType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(FNCombineType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(FNCombineType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            FNCombineType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (FNCombineType) -1;
        }
    } else {
        FNCombineType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (FNCombineType) -1;
        val = __Pyx_PyInt_As_FNCombineType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to FNCombineType");
    return (FNCombineType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to FNCombineType");
    return (FNCombineType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE RGQuadRule __Pyx_PyInt_As_RGQuadRule(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const RGQuadRule neg_one = (RGQuadRule) -1, const_zero = (RGQuadRule) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(RGQuadRule) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(RGQuadRule, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (RGQuadRule) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (RGQuadRule) 0;
                case  1: __PYX_VERIFY_RETURN_INT(RGQuadRule, digit, digits[0])
                case 2:
                    if (8 * sizeof(RGQuadRule) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(RGQuadRule, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(RGQuadRule) >= 2 * PyLong_SHIFT) {
                            return (RGQuadRule) (((((RGQuadRule)digits[1]) << PyLong_SHIFT) | (RGQuadRule)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(RGQuadRule) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(RGQuadRule, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(RGQuadRule) >= 3 * PyLong_SHIFT) {
                            return (RGQuadRule) (((((((RGQuadRule)digits[2]) << PyLong_SHIFT) | (RGQuadRule)digits[1]) << PyLong_SHIFT) | (RGQuadRule)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(RGQuadRule) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(RGQuadRule, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(RGQuadRule) >= 4 * PyLong_SHIFT) {
                            return (RGQuadRule) (((((((((RGQuadRule)digits[3]) << PyLong_SHIFT) | (RGQuadRule)digits[2]) << PyLong_SHIFT) | (RGQuadRule)digits[1]) << PyLong_SHIFT) | (RGQuadRule)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (RGQuadRule) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(RGQuadRule) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(RGQuadRule, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(RGQuadRule) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(RGQuadRule, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (RGQuadRule) 0;
                case -1: __PYX_VERIFY_RETURN_INT(RGQuadRule, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(RGQuadRule,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(RGQuadRule) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(RGQuadRule, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(RGQuadRule) - 1 > 2 * PyLong_SHIFT) {
                            return (RGQuadRule) (((RGQuadRule)-1)*(((((RGQuadRule)digits[1]) << PyLong_SHIFT) | (RGQuadRule)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(RGQuadRule) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(RGQuadRule, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(RGQuadRule) - 1 > 2 * PyLong_SHIFT) {
                            return (RGQuadRule) ((((((RGQuadRule)digits[1]) << PyLong_SHIFT) | (RGQuadRule)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(RGQuadRule) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(RGQuadRule, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(RGQuadRule) - 1 > 3 * PyLong_SHIFT) {
                            return (RGQuadRule) (((RGQuadRule)-1)*(((((((RGQuadRule)digits[2]) << PyLong_SHIFT) | (RGQuadRule)digits[1]) << PyLong_SHIFT) | (RGQuadRule)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(RGQuadRule) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(RGQuadRule, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(RGQuadRule) - 1 > 3 * PyLong_SHIFT) {
                            return (RGQuadRule) ((((((((RGQuadRule)digits[2]) << PyLong_SHIFT) | (RGQuadRule)digits[1]) << PyLong_SHIFT) | (RGQuadRule)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(RGQuadRule) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(RGQuadRule, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(RGQuadRule) - 1 > 4 * PyLong_SHIFT) {
                            return (RGQuadRule) (((RGQuadRule)-1)*(((((((((RGQuadRule)digits[3]) << PyLong_SHIFT) | (RGQuadRule)digits[2]) << PyLong_SHIFT) | (RGQuadRule)digits[1]) << PyLong_SHIFT) | (RGQuadRule)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(RGQuadRule) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(RGQuadRule, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(RGQuadRule) - 1 > 4 * PyLong_SHIFT) {
                            return (RGQuadRule) ((((((((((RGQuadRule)digits[3]) << PyLong_SHIFT) | (RGQuadRule)digits[2]) << PyLong_SHIFT) | (RGQuadRule)digits[1]) << PyLong_SHIFT) | (RGQuadRule)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(RGQuadRule) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(RGQuadRule, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(RGQuadRule) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(RGQuadRule, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            RGQuadRule val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (RGQuadRule) -1;
        }
    } else {
        RGQuadRule val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (RGQuadRule) -1;
        val = __Pyx_PyInt_As_RGQuadRule(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to RGQuadRule");
    return (RGQuadRule) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to RGQuadRule");
    return (RGQuadRule) -1;
}

/* CIntFromPy */
static CYTHON_INLINE EPSProblemType __Pyx_PyInt_As_EPSProblemType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSProblemType neg_one = (EPSProblemType) -1, const_zero = (EPSProblemType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(EPSProblemType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(EPSProblemType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (EPSProblemType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSProblemType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(EPSProblemType, digit, digits[0])
                case 2:
                    if (8 * sizeof(EPSProblemType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSProblemType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSProblemType) >= 2 * PyLong_SHIFT) {
                            return (EPSProblemType) (((((EPSProblemType)digits[1]) << PyLong_SHIFT) | (EPSProblemType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSProblemType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSProblemType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSProblemType) >= 3 * PyLong_SHIFT) {
                            return (EPSProblemType) (((((((EPSProblemType)digits[2]) << PyLong_SHIFT) | (EPSProblemType)digits[1]) << PyLong_SHIFT) | (EPSProblemType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSProblemType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSProblemType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSProblemType) >= 4 * PyLong_SHIFT) {
                            return (EPSProblemType) (((((((((EPSProblemType)digits[3]) << PyLong_SHIFT) | (EPSProblemType)digits[2]) << PyLong_SHIFT) | (EPSProblemType)digits[1]) << PyLong_SHIFT) | (EPSProblemType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (EPSProblemType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(EPSProblemType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSProblemType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSProblemType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSProblemType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSProblemType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(EPSProblemType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(EPSProblemType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(EPSProblemType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSProblemType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSProblemType) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSProblemType) (((EPSProblemType)-1)*(((((EPSProblemType)digits[1]) << PyLong_SHIFT) | (EPSProblemType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(EPSProblemType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSProblemType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSProblemType) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSProblemType) ((((((EPSProblemType)digits[1]) << PyLong_SHIFT) | (EPSProblemType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(EPSProblemType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSProblemType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSProblemType) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSProblemType) (((EPSProblemType)-1)*(((((((EPSProblemType)digits[2]) << PyLong_SHIFT) | (EPSProblemType)digits[1]) << PyLong_SHIFT) | (EPSProblemType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSProblemType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSProblemType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSProblemType) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSProblemType) ((((((((EPSProblemType)digits[2]) << PyLong_SHIFT) | (EPSProblemType)digits[1]) << PyLong_SHIFT) | (EPSProblemType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(EPSProblemType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSProblemType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSProblemType) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSProblemType) (((EPSProblemType)-1)*(((((((((EPSProblemType)digits[3]) << PyLong_SHIFT) | (EPSProblemType)digits[2]) << PyLong_SHIFT) | (EPSProblemType)digits[1]) << PyLong_SHIFT) | (EPSProblemType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSProblemType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSProblemType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSProblemType) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSProblemType) ((((((((((EPSProblemType)digits[3]) << PyLong_SHIFT) | (EPSProblemType)digits[2]) << PyLong_SHIFT) | (EPSProblemType)digits[1]) << PyLong_SHIFT) | (EPSProblemType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(EPSProblemType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSProblemType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSProblemType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSProblemType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            EPSProblemType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (EPSProblemType) -1;
        }
    } else {
        EPSProblemType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (EPSProblemType) -1;
        val = __Pyx_PyInt_As_EPSProblemType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to EPSProblemType");
    return (EPSProblemType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to EPSProblemType");
    return (EPSProblemType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE EPSBalance __Pyx_PyInt_As_EPSBalance(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSBalance neg_one = (EPSBalance) -1, const_zero = (EPSBalance) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(EPSBalance) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(EPSBalance, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (EPSBalance) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSBalance) 0;
                case  1: __PYX_VERIFY_RETURN_INT(EPSBalance, digit, digits[0])
                case 2:
                    if (8 * sizeof(EPSBalance) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSBalance, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSBalance) >= 2 * PyLong_SHIFT) {
                            return (EPSBalance) (((((EPSBalance)digits[1]) << PyLong_SHIFT) | (EPSBalance)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSBalance) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSBalance, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSBalance) >= 3 * PyLong_SHIFT) {
                            return (EPSBalance) (((((((EPSBalance)digits[2]) << PyLong_SHIFT) | (EPSBalance)digits[1]) << PyLong_SHIFT) | (EPSBalance)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSBalance) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSBalance, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSBalance) >= 4 * PyLong_SHIFT) {
                            return (EPSBalance) (((((((((EPSBalance)digits[3]) << PyLong_SHIFT) | (EPSBalance)digits[2]) << PyLong_SHIFT) | (EPSBalance)digits[1]) << PyLong_SHIFT) | (EPSBalance)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (EPSBalance) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(EPSBalance) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSBalance, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSBalance) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSBalance, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSBalance) 0;
                case -1: __PYX_VERIFY_RETURN_INT(EPSBalance, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(EPSBalance,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(EPSBalance) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSBalance, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSBalance) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSBalance) (((EPSBalance)-1)*(((((EPSBalance)digits[1]) << PyLong_SHIFT) | (EPSBalance)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(EPSBalance) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSBalance, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSBalance) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSBalance) ((((((EPSBalance)digits[1]) << PyLong_SHIFT) | (EPSBalance)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(EPSBalance) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSBalance, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSBalance) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSBalance) (((EPSBalance)-1)*(((((((EPSBalance)digits[2]) << PyLong_SHIFT) | (EPSBalance)digits[1]) << PyLong_SHIFT) | (EPSBalance)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSBalance) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSBalance, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSBalance) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSBalance) ((((((((EPSBalance)digits[2]) << PyLong_SHIFT) | (EPSBalance)digits[1]) << PyLong_SHIFT) | (EPSBalance)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(EPSBalance) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSBalance, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSBalance) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSBalance) (((EPSBalance)-1)*(((((((((EPSBalance)digits[3]) << PyLong_SHIFT) | (EPSBalance)digits[2]) << PyLong_SHIFT) | (EPSBalance)digits[1]) << PyLong_SHIFT) | (EPSBalance)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSBalance) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSBalance, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSBalance) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSBalance) ((((((((((EPSBalance)digits[3]) << PyLong_SHIFT) | (EPSBalance)digits[2]) << PyLong_SHIFT) | (EPSBalance)digits[1]) << PyLong_SHIFT) | (EPSBalance)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(EPSBalance) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSBalance, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSBalance) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSBalance, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            EPSBalance val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (EPSBalance) -1;
        }
    } else {
        EPSBalance val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (EPSBalance) -1;
        val = __Pyx_PyInt_As_EPSBalance(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to EPSBalance");
    return (EPSBalance) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to EPSBalance");
    return (EPSBalance) -1;
}

/* CIntFromPy */
static CYTHON_INLINE EPSExtraction __Pyx_PyInt_As_EPSExtraction(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSExtraction neg_one = (EPSExtraction) -1, const_zero = (EPSExtraction) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(EPSExtraction) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(EPSExtraction, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (EPSExtraction) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSExtraction) 0;
                case  1: __PYX_VERIFY_RETURN_INT(EPSExtraction, digit, digits[0])
                case 2:
                    if (8 * sizeof(EPSExtraction) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSExtraction, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSExtraction) >= 2 * PyLong_SHIFT) {
                            return (EPSExtraction) (((((EPSExtraction)digits[1]) << PyLong_SHIFT) | (EPSExtraction)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSExtraction) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSExtraction, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSExtraction) >= 3 * PyLong_SHIFT) {
                            return (EPSExtraction) (((((((EPSExtraction)digits[2]) << PyLong_SHIFT) | (EPSExtraction)digits[1]) << PyLong_SHIFT) | (EPSExtraction)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSExtraction) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSExtraction, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSExtraction) >= 4 * PyLong_SHIFT) {
                            return (EPSExtraction) (((((((((EPSExtraction)digits[3]) << PyLong_SHIFT) | (EPSExtraction)digits[2]) << PyLong_SHIFT) | (EPSExtraction)digits[1]) << PyLong_SHIFT) | (EPSExtraction)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (EPSExtraction) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(EPSExtraction) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSExtraction, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSExtraction) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSExtraction, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSExtraction) 0;
                case -1: __PYX_VERIFY_RETURN_INT(EPSExtraction, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(EPSExtraction,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(EPSExtraction) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSExtraction, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSExtraction) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSExtraction) (((EPSExtraction)-1)*(((((EPSExtraction)digits[1]) << PyLong_SHIFT) | (EPSExtraction)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(EPSExtraction) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSExtraction, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSExtraction) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSExtraction) ((((((EPSExtraction)digits[1]) << PyLong_SHIFT) | (EPSExtraction)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(EPSExtraction) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSExtraction, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSExtraction) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSExtraction) (((EPSExtraction)-1)*(((((((EPSExtraction)digits[2]) << PyLong_SHIFT) | (EPSExtraction)digits[1]) << PyLong_SHIFT) | (EPSExtraction)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSExtraction) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSExtraction, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSExtraction) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSExtraction) ((((((((EPSExtraction)digits[2]) << PyLong_SHIFT) | (EPSExtraction)digits[1]) << PyLong_SHIFT) | (EPSExtraction)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(EPSExtraction) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSExtraction, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSExtraction) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSExtraction) (((EPSExtraction)-1)*(((((((((EPSExtraction)digits[3]) << PyLong_SHIFT) | (EPSExtraction)digits[2]) << PyLong_SHIFT) | (EPSExtraction)digits[1]) << PyLong_SHIFT) | (EPSExtraction)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSExtraction) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSExtraction, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSExtraction) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSExtraction) ((((((((((EPSExtraction)digits[3]) << PyLong_SHIFT) | (EPSExtraction)digits[2]) << PyLong_SHIFT) | (EPSExtraction)digits[1]) << PyLong_SHIFT) | (EPSExtraction)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(EPSExtraction) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSExtraction, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSExtraction) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSExtraction, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            EPSExtraction val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (EPSExtraction) -1;
        }
    } else {
        EPSExtraction val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (EPSExtraction) -1;
        val = __Pyx_PyInt_As_EPSExtraction(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to EPSExtraction");
    return (EPSExtraction) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to EPSExtraction");
    return (EPSExtraction) -1;
}

/* CIntFromPy */
static CYTHON_INLINE EPSWhich __Pyx_PyInt_As_EPSWhich(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSWhich neg_one = (EPSWhich) -1, const_zero = (EPSWhich) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(EPSWhich) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(EPSWhich, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (EPSWhich) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSWhich) 0;
                case  1: __PYX_VERIFY_RETURN_INT(EPSWhich, digit, digits[0])
                case 2:
                    if (8 * sizeof(EPSWhich) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSWhich, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSWhich) >= 2 * PyLong_SHIFT) {
                            return (EPSWhich) (((((EPSWhich)digits[1]) << PyLong_SHIFT) | (EPSWhich)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSWhich) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSWhich, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSWhich) >= 3 * PyLong_SHIFT) {
                            return (EPSWhich) (((((((EPSWhich)digits[2]) << PyLong_SHIFT) | (EPSWhich)digits[1]) << PyLong_SHIFT) | (EPSWhich)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSWhich) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSWhich, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSWhich) >= 4 * PyLong_SHIFT) {
                            return (EPSWhich) (((((((((EPSWhich)digits[3]) << PyLong_SHIFT) | (EPSWhich)digits[2]) << PyLong_SHIFT) | (EPSWhich)digits[1]) << PyLong_SHIFT) | (EPSWhich)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (EPSWhich) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(EPSWhich) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSWhich, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSWhich) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSWhich, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSWhich) 0;
                case -1: __PYX_VERIFY_RETURN_INT(EPSWhich, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(EPSWhich,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(EPSWhich) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSWhich, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSWhich) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSWhich) (((EPSWhich)-1)*(((((EPSWhich)digits[1]) << PyLong_SHIFT) | (EPSWhich)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(EPSWhich) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSWhich, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSWhich) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSWhich) ((((((EPSWhich)digits[1]) << PyLong_SHIFT) | (EPSWhich)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(EPSWhich) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSWhich, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSWhich) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSWhich) (((EPSWhich)-1)*(((((((EPSWhich)digits[2]) << PyLong_SHIFT) | (EPSWhich)digits[1]) << PyLong_SHIFT) | (EPSWhich)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSWhich) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSWhich, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSWhich) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSWhich) ((((((((EPSWhich)digits[2]) << PyLong_SHIFT) | (EPSWhich)digits[1]) << PyLong_SHIFT) | (EPSWhich)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(EPSWhich) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSWhich, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSWhich) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSWhich) (((EPSWhich)-1)*(((((((((EPSWhich)digits[3]) << PyLong_SHIFT) | (EPSWhich)digits[2]) << PyLong_SHIFT) | (EPSWhich)digits[1]) << PyLong_SHIFT) | (EPSWhich)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSWhich) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSWhich, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSWhich) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSWhich) ((((((((((EPSWhich)digits[3]) << PyLong_SHIFT) | (EPSWhich)digits[2]) << PyLong_SHIFT) | (EPSWhich)digits[1]) << PyLong_SHIFT) | (EPSWhich)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(EPSWhich) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSWhich, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSWhich) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSWhich, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            EPSWhich val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (EPSWhich) -1;
        }
    } else {
        EPSWhich val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (EPSWhich) -1;
        val = __Pyx_PyInt_As_EPSWhich(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to EPSWhich");
    return (EPSWhich) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to EPSWhich");
    return (EPSWhich) -1;
}

/* CIntFromPy */
static CYTHON_INLINE EPSConv __Pyx_PyInt_As_EPSConv(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSConv neg_one = (EPSConv) -1, const_zero = (EPSConv) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(EPSConv) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(EPSConv, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (EPSConv) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSConv) 0;
                case  1: __PYX_VERIFY_RETURN_INT(EPSConv, digit, digits[0])
                case 2:
                    if (8 * sizeof(EPSConv) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConv, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConv) >= 2 * PyLong_SHIFT) {
                            return (EPSConv) (((((EPSConv)digits[1]) << PyLong_SHIFT) | (EPSConv)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSConv) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConv, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConv) >= 3 * PyLong_SHIFT) {
                            return (EPSConv) (((((((EPSConv)digits[2]) << PyLong_SHIFT) | (EPSConv)digits[1]) << PyLong_SHIFT) | (EPSConv)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSConv) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConv, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConv) >= 4 * PyLong_SHIFT) {
                            return (EPSConv) (((((((((EPSConv)digits[3]) << PyLong_SHIFT) | (EPSConv)digits[2]) << PyLong_SHIFT) | (EPSConv)digits[1]) << PyLong_SHIFT) | (EPSConv)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (EPSConv) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(EPSConv) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSConv, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSConv) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSConv, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSConv) 0;
                case -1: __PYX_VERIFY_RETURN_INT(EPSConv, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(EPSConv,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(EPSConv) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConv, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConv) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSConv) (((EPSConv)-1)*(((((EPSConv)digits[1]) << PyLong_SHIFT) | (EPSConv)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(EPSConv) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConv, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConv) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSConv) ((((((EPSConv)digits[1]) << PyLong_SHIFT) | (EPSConv)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(EPSConv) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConv, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConv) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSConv) (((EPSConv)-1)*(((((((EPSConv)digits[2]) << PyLong_SHIFT) | (EPSConv)digits[1]) << PyLong_SHIFT) | (EPSConv)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSConv) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConv, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConv) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSConv) ((((((((EPSConv)digits[2]) << PyLong_SHIFT) | (EPSConv)digits[1]) << PyLong_SHIFT) | (EPSConv)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(EPSConv) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConv, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConv) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSConv) (((EPSConv)-1)*(((((((((EPSConv)digits[3]) << PyLong_SHIFT) | (EPSConv)digits[2]) << PyLong_SHIFT) | (EPSConv)digits[1]) << PyLong_SHIFT) | (EPSConv)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSConv) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSConv, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSConv) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSConv) ((((((((((EPSConv)digits[3]) << PyLong_SHIFT) | (EPSConv)digits[2]) << PyLong_SHIFT) | (EPSConv)digits[1]) << PyLong_SHIFT) | (EPSConv)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(EPSConv) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSConv, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSConv) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSConv, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            EPSConv val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (EPSConv) -1;
        }
    } else {
        EPSConv val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (EPSConv) -1;
        val = __Pyx_PyInt_As_EPSConv(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to EPSConv");
    return (EPSConv) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to EPSConv");
    return (EPSConv) -1;
}

/* CIntFromPy */
static CYTHON_INLINE EPSErrorType __Pyx_PyInt_As_EPSErrorType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSErrorType neg_one = (EPSErrorType) -1, const_zero = (EPSErrorType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(EPSErrorType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(EPSErrorType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (EPSErrorType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSErrorType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(EPSErrorType, digit, digits[0])
                case 2:
                    if (8 * sizeof(EPSErrorType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSErrorType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSErrorType) >= 2 * PyLong_SHIFT) {
                            return (EPSErrorType) (((((EPSErrorType)digits[1]) << PyLong_SHIFT) | (EPSErrorType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSErrorType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSErrorType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSErrorType) >= 3 * PyLong_SHIFT) {
                            return (EPSErrorType) (((((((EPSErrorType)digits[2]) << PyLong_SHIFT) | (EPSErrorType)digits[1]) << PyLong_SHIFT) | (EPSErrorType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSErrorType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSErrorType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSErrorType) >= 4 * PyLong_SHIFT) {
                            return (EPSErrorType) (((((((((EPSErrorType)digits[3]) << PyLong_SHIFT) | (EPSErrorType)digits[2]) << PyLong_SHIFT) | (EPSErrorType)digits[1]) << PyLong_SHIFT) | (EPSErrorType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (EPSErrorType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(EPSErrorType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSErrorType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSErrorType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSErrorType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSErrorType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(EPSErrorType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(EPSErrorType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(EPSErrorType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSErrorType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSErrorType) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSErrorType) (((EPSErrorType)-1)*(((((EPSErrorType)digits[1]) << PyLong_SHIFT) | (EPSErrorType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(EPSErrorType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSErrorType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSErrorType) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSErrorType) ((((((EPSErrorType)digits[1]) << PyLong_SHIFT) | (EPSErrorType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(EPSErrorType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSErrorType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSErrorType) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSErrorType) (((EPSErrorType)-1)*(((((((EPSErrorType)digits[2]) << PyLong_SHIFT) | (EPSErrorType)digits[1]) << PyLong_SHIFT) | (EPSErrorType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSErrorType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSErrorType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSErrorType) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSErrorType) ((((((((EPSErrorType)digits[2]) << PyLong_SHIFT) | (EPSErrorType)digits[1]) << PyLong_SHIFT) | (EPSErrorType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(EPSErrorType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSErrorType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSErrorType) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSErrorType) (((EPSErrorType)-1)*(((((((((EPSErrorType)digits[3]) << PyLong_SHIFT) | (EPSErrorType)digits[2]) << PyLong_SHIFT) | (EPSErrorType)digits[1]) << PyLong_SHIFT) | (EPSErrorType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSErrorType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSErrorType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSErrorType) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSErrorType) ((((((((((EPSErrorType)digits[3]) << PyLong_SHIFT) | (EPSErrorType)digits[2]) << PyLong_SHIFT) | (EPSErrorType)digits[1]) << PyLong_SHIFT) | (EPSErrorType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(EPSErrorType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSErrorType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSErrorType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSErrorType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            EPSErrorType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (EPSErrorType) -1;
        }
    } else {
        EPSErrorType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (EPSErrorType) -1;
        val = __Pyx_PyInt_As_EPSErrorType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to EPSErrorType");
    return (EPSErrorType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to EPSErrorType");
    return (EPSErrorType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE EPSPowerShiftType __Pyx_PyInt_As_EPSPowerShiftType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSPowerShiftType neg_one = (EPSPowerShiftType) -1, const_zero = (EPSPowerShiftType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(EPSPowerShiftType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(EPSPowerShiftType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (EPSPowerShiftType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSPowerShiftType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(EPSPowerShiftType, digit, digits[0])
                case 2:
                    if (8 * sizeof(EPSPowerShiftType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSPowerShiftType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSPowerShiftType) >= 2 * PyLong_SHIFT) {
                            return (EPSPowerShiftType) (((((EPSPowerShiftType)digits[1]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSPowerShiftType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSPowerShiftType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSPowerShiftType) >= 3 * PyLong_SHIFT) {
                            return (EPSPowerShiftType) (((((((EPSPowerShiftType)digits[2]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[1]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSPowerShiftType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSPowerShiftType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSPowerShiftType) >= 4 * PyLong_SHIFT) {
                            return (EPSPowerShiftType) (((((((((EPSPowerShiftType)digits[3]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[2]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[1]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (EPSPowerShiftType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(EPSPowerShiftType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSPowerShiftType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSPowerShiftType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSPowerShiftType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSPowerShiftType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(EPSPowerShiftType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(EPSPowerShiftType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(EPSPowerShiftType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSPowerShiftType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSPowerShiftType) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSPowerShiftType) (((EPSPowerShiftType)-1)*(((((EPSPowerShiftType)digits[1]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(EPSPowerShiftType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSPowerShiftType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSPowerShiftType) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSPowerShiftType) ((((((EPSPowerShiftType)digits[1]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(EPSPowerShiftType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSPowerShiftType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSPowerShiftType) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSPowerShiftType) (((EPSPowerShiftType)-1)*(((((((EPSPowerShiftType)digits[2]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[1]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSPowerShiftType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSPowerShiftType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSPowerShiftType) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSPowerShiftType) ((((((((EPSPowerShiftType)digits[2]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[1]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(EPSPowerShiftType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSPowerShiftType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSPowerShiftType) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSPowerShiftType) (((EPSPowerShiftType)-1)*(((((((((EPSPowerShiftType)digits[3]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[2]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[1]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSPowerShiftType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSPowerShiftType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSPowerShiftType) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSPowerShiftType) ((((((((((EPSPowerShiftType)digits[3]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[2]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[1]) << PyLong_SHIFT) | (EPSPowerShiftType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(EPSPowerShiftType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSPowerShiftType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSPowerShiftType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSPowerShiftType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            EPSPowerShiftType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (EPSPowerShiftType) -1;
        }
    } else {
        EPSPowerShiftType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (EPSPowerShiftType) -1;
        val = __Pyx_PyInt_As_EPSPowerShiftType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to EPSPowerShiftType");
    return (EPSPowerShiftType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to EPSPowerShiftType");
    return (EPSPowerShiftType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE EPSLanczosReorthogType __Pyx_PyInt_As_EPSLanczosReorthogType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSLanczosReorthogType neg_one = (EPSLanczosReorthogType) -1, const_zero = (EPSLanczosReorthogType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(EPSLanczosReorthogType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(EPSLanczosReorthogType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (EPSLanczosReorthogType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSLanczosReorthogType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(EPSLanczosReorthogType, digit, digits[0])
                case 2:
                    if (8 * sizeof(EPSLanczosReorthogType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSLanczosReorthogType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSLanczosReorthogType) >= 2 * PyLong_SHIFT) {
                            return (EPSLanczosReorthogType) (((((EPSLanczosReorthogType)digits[1]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSLanczosReorthogType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSLanczosReorthogType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSLanczosReorthogType) >= 3 * PyLong_SHIFT) {
                            return (EPSLanczosReorthogType) (((((((EPSLanczosReorthogType)digits[2]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[1]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSLanczosReorthogType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSLanczosReorthogType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSLanczosReorthogType) >= 4 * PyLong_SHIFT) {
                            return (EPSLanczosReorthogType) (((((((((EPSLanczosReorthogType)digits[3]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[2]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[1]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (EPSLanczosReorthogType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(EPSLanczosReorthogType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSLanczosReorthogType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSLanczosReorthogType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSLanczosReorthogType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSLanczosReorthogType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(EPSLanczosReorthogType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(EPSLanczosReorthogType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(EPSLanczosReorthogType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSLanczosReorthogType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSLanczosReorthogType) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSLanczosReorthogType) (((EPSLanczosReorthogType)-1)*(((((EPSLanczosReorthogType)digits[1]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(EPSLanczosReorthogType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSLanczosReorthogType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSLanczosReorthogType) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSLanczosReorthogType) ((((((EPSLanczosReorthogType)digits[1]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(EPSLanczosReorthogType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSLanczosReorthogType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSLanczosReorthogType) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSLanczosReorthogType) (((EPSLanczosReorthogType)-1)*(((((((EPSLanczosReorthogType)digits[2]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[1]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSLanczosReorthogType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSLanczosReorthogType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSLanczosReorthogType) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSLanczosReorthogType) ((((((((EPSLanczosReorthogType)digits[2]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[1]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(EPSLanczosReorthogType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSLanczosReorthogType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSLanczosReorthogType) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSLanczosReorthogType) (((EPSLanczosReorthogType)-1)*(((((((((EPSLanczosReorthogType)digits[3]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[2]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[1]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSLanczosReorthogType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSLanczosReorthogType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSLanczosReorthogType) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSLanczosReorthogType) ((((((((((EPSLanczosReorthogType)digits[3]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[2]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[1]) << PyLong_SHIFT) | (EPSLanczosReorthogType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(EPSLanczosReorthogType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSLanczosReorthogType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSLanczosReorthogType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSLanczosReorthogType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            EPSLanczosReorthogType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (EPSLanczosReorthogType) -1;
        }
    } else {
        EPSLanczosReorthogType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (EPSLanczosReorthogType) -1;
        val = __Pyx_PyInt_As_EPSLanczosReorthogType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to EPSLanczosReorthogType");
    return (EPSLanczosReorthogType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to EPSLanczosReorthogType");
    return (EPSLanczosReorthogType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE PetscBool __Pyx_PyInt_As_PetscBool(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PetscBool neg_one = (PetscBool) -1, const_zero = (PetscBool) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(PetscBool) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(PetscBool, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (PetscBool) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PetscBool) 0;
                case  1: __PYX_VERIFY_RETURN_INT(PetscBool, digit, digits[0])
                case 2:
                    if (8 * sizeof(PetscBool) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscBool, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscBool) >= 2 * PyLong_SHIFT) {
                            return (PetscBool) (((((PetscBool)digits[1]) << PyLong_SHIFT) | (PetscBool)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PetscBool) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscBool, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscBool) >= 3 * PyLong_SHIFT) {
                            return (PetscBool) (((((((PetscBool)digits[2]) << PyLong_SHIFT) | (PetscBool)digits[1]) << PyLong_SHIFT) | (PetscBool)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PetscBool) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscBool, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscBool) >= 4 * PyLong_SHIFT) {
                            return (PetscBool) (((((((((PetscBool)digits[3]) << PyLong_SHIFT) | (PetscBool)digits[2]) << PyLong_SHIFT) | (PetscBool)digits[1]) << PyLong_SHIFT) | (PetscBool)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (PetscBool) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(PetscBool) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PetscBool, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PetscBool) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PetscBool, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PetscBool) 0;
                case -1: __PYX_VERIFY_RETURN_INT(PetscBool, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(PetscBool,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(PetscBool) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscBool, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscBool) - 1 > 2 * PyLong_SHIFT) {
                            return (PetscBool) (((PetscBool)-1)*(((((PetscBool)digits[1]) << PyLong_SHIFT) | (PetscBool)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(PetscBool) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscBool, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscBool) - 1 > 2 * PyLong_SHIFT) {
                            return (PetscBool) ((((((PetscBool)digits[1]) << PyLong_SHIFT) | (PetscBool)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(PetscBool) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscBool, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscBool) - 1 > 3 * PyLong_SHIFT) {
                            return (PetscBool) (((PetscBool)-1)*(((((((PetscBool)digits[2]) << PyLong_SHIFT) | (PetscBool)digits[1]) << PyLong_SHIFT) | (PetscBool)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PetscBool) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscBool, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscBool) - 1 > 3 * PyLong_SHIFT) {
                            return (PetscBool) ((((((((PetscBool)digits[2]) << PyLong_SHIFT) | (PetscBool)digits[1]) << PyLong_SHIFT) | (PetscBool)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(PetscBool) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscBool, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscBool) - 1 > 4 * PyLong_SHIFT) {
                            return (PetscBool) (((PetscBool)-1)*(((((((((PetscBool)digits[3]) << PyLong_SHIFT) | (PetscBool)digits[2]) << PyLong_SHIFT) | (PetscBool)digits[1]) << PyLong_SHIFT) | (PetscBool)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PetscBool) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PetscBool, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PetscBool) - 1 > 4 * PyLong_SHIFT) {
                            return (PetscBool) ((((((((((PetscBool)digits[3]) << PyLong_SHIFT) | (PetscBool)digits[2]) << PyLong_SHIFT) | (PetscBool)digits[1]) << PyLong_SHIFT) | (PetscBool)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(PetscBool) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PetscBool, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PetscBool) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PetscBool, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            PetscBool val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (PetscBool) -1;
        }
    } else {
        PetscBool val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (PetscBool) -1;
        val = __Pyx_PyInt_As_PetscBool(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to PetscBool");
    return (PetscBool) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to PetscBool");
    return (PetscBool) -1;
}

/* CIntFromPy */
static CYTHON_INLINE EPSCISSExtraction __Pyx_PyInt_As_EPSCISSExtraction(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSCISSExtraction neg_one = (EPSCISSExtraction) -1, const_zero = (EPSCISSExtraction) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(EPSCISSExtraction) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(EPSCISSExtraction, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (EPSCISSExtraction) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSCISSExtraction) 0;
                case  1: __PYX_VERIFY_RETURN_INT(EPSCISSExtraction, digit, digits[0])
                case 2:
                    if (8 * sizeof(EPSCISSExtraction) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSExtraction, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSExtraction) >= 2 * PyLong_SHIFT) {
                            return (EPSCISSExtraction) (((((EPSCISSExtraction)digits[1]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSCISSExtraction) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSExtraction, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSExtraction) >= 3 * PyLong_SHIFT) {
                            return (EPSCISSExtraction) (((((((EPSCISSExtraction)digits[2]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[1]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSCISSExtraction) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSExtraction, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSExtraction) >= 4 * PyLong_SHIFT) {
                            return (EPSCISSExtraction) (((((((((EPSCISSExtraction)digits[3]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[2]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[1]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (EPSCISSExtraction) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(EPSCISSExtraction) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSCISSExtraction, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSCISSExtraction) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSCISSExtraction, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSCISSExtraction) 0;
                case -1: __PYX_VERIFY_RETURN_INT(EPSCISSExtraction, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(EPSCISSExtraction,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(EPSCISSExtraction) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSExtraction, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSExtraction) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSCISSExtraction) (((EPSCISSExtraction)-1)*(((((EPSCISSExtraction)digits[1]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(EPSCISSExtraction) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSExtraction, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSExtraction) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSCISSExtraction) ((((((EPSCISSExtraction)digits[1]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(EPSCISSExtraction) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSExtraction, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSExtraction) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSCISSExtraction) (((EPSCISSExtraction)-1)*(((((((EPSCISSExtraction)digits[2]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[1]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSCISSExtraction) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSExtraction, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSExtraction) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSCISSExtraction) ((((((((EPSCISSExtraction)digits[2]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[1]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(EPSCISSExtraction) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSExtraction, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSExtraction) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSCISSExtraction) (((EPSCISSExtraction)-1)*(((((((((EPSCISSExtraction)digits[3]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[2]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[1]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSCISSExtraction) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSExtraction, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSExtraction) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSCISSExtraction) ((((((((((EPSCISSExtraction)digits[3]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[2]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[1]) << PyLong_SHIFT) | (EPSCISSExtraction)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(EPSCISSExtraction) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSCISSExtraction, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSCISSExtraction) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSCISSExtraction, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            EPSCISSExtraction val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (EPSCISSExtraction) -1;
        }
    } else {
        EPSCISSExtraction val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (EPSCISSExtraction) -1;
        val = __Pyx_PyInt_As_EPSCISSExtraction(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to EPSCISSExtraction");
    return (EPSCISSExtraction) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to EPSCISSExtraction");
    return (EPSCISSExtraction) -1;
}

/* CIntFromPy */
static CYTHON_INLINE EPSCISSQuadRule __Pyx_PyInt_As_EPSCISSQuadRule(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const EPSCISSQuadRule neg_one = (EPSCISSQuadRule) -1, const_zero = (EPSCISSQuadRule) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(EPSCISSQuadRule) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(EPSCISSQuadRule, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (EPSCISSQuadRule) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSCISSQuadRule) 0;
                case  1: __PYX_VERIFY_RETURN_INT(EPSCISSQuadRule, digit, digits[0])
                case 2:
                    if (8 * sizeof(EPSCISSQuadRule) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSQuadRule, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSQuadRule) >= 2 * PyLong_SHIFT) {
                            return (EPSCISSQuadRule) (((((EPSCISSQuadRule)digits[1]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSCISSQuadRule) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSQuadRule, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSQuadRule) >= 3 * PyLong_SHIFT) {
                            return (EPSCISSQuadRule) (((((((EPSCISSQuadRule)digits[2]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[1]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSCISSQuadRule) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSQuadRule, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSQuadRule) >= 4 * PyLong_SHIFT) {
                            return (EPSCISSQuadRule) (((((((((EPSCISSQuadRule)digits[3]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[2]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[1]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (EPSCISSQuadRule) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(EPSCISSQuadRule) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSCISSQuadRule, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSCISSQuadRule) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSCISSQuadRule, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (EPSCISSQuadRule) 0;
                case -1: __PYX_VERIFY_RETURN_INT(EPSCISSQuadRule, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(EPSCISSQuadRule,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(EPSCISSQuadRule) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSQuadRule, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSQuadRule) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSCISSQuadRule) (((EPSCISSQuadRule)-1)*(((((EPSCISSQuadRule)digits[1]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(EPSCISSQuadRule) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSQuadRule, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSQuadRule) - 1 > 2 * PyLong_SHIFT) {
                            return (EPSCISSQuadRule) ((((((EPSCISSQuadRule)digits[1]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(EPSCISSQuadRule) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSQuadRule, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSQuadRule) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSCISSQuadRule) (((EPSCISSQuadRule)-1)*(((((((EPSCISSQuadRule)digits[2]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[1]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(EPSCISSQuadRule) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSQuadRule, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSQuadRule) - 1 > 3 * PyLong_SHIFT) {
                            return (EPSCISSQuadRule) ((((((((EPSCISSQuadRule)digits[2]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[1]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(EPSCISSQuadRule) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSQuadRule, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSQuadRule) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSCISSQuadRule) (((EPSCISSQuadRule)-1)*(((((((((EPSCISSQuadRule)digits[3]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[2]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[1]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(EPSCISSQuadRule) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(EPSCISSQuadRule, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(EPSCISSQuadRule) - 1 > 4 * PyLong_SHIFT) {
                            return (EPSCISSQuadRule) ((((((((((EPSCISSQuadRule)digits[3]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[2]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[1]) << PyLong_SHIFT) | (EPSCISSQuadRule)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(EPSCISSQuadRule) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSCISSQuadRule, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(EPSCISSQuadRule) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(EPSCISSQuadRule, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            EPSCISSQuadRule val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (EPSCISSQuadRule) -1;
        }
    } else {
        EPSCISSQuadRule val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (EPSCISSQuadRule) -1;
        val = __Pyx_PyInt_As_EPSCISSQuadRule(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to EPSCISSQuadRule");
    return (EPSCISSQuadRule) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to EPSCISSQuadRule");
    return (EPSCISSQuadRule) -1;
}

/* CIntFromPy */
static CYTHON_INLINE SVDProblemType __Pyx_PyInt_As_SVDProblemType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const SVDProblemType neg_one = (SVDProblemType) -1, const_zero = (SVDProblemType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(SVDProblemType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(SVDProblemType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (SVDProblemType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (SVDProblemType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(SVDProblemType, digit, digits[0])
                case 2:
                    if (8 * sizeof(SVDProblemType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDProblemType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDProblemType) >= 2 * PyLong_SHIFT) {
                            return (SVDProblemType) (((((SVDProblemType)digits[1]) << PyLong_SHIFT) | (SVDProblemType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(SVDProblemType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDProblemType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDProblemType) >= 3 * PyLong_SHIFT) {
                            return (SVDProblemType) (((((((SVDProblemType)digits[2]) << PyLong_SHIFT) | (SVDProblemType)digits[1]) << PyLong_SHIFT) | (SVDProblemType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(SVDProblemType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDProblemType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDProblemType) >= 4 * PyLong_SHIFT) {
                            return (SVDProblemType) (((((((((SVDProblemType)digits[3]) << PyLong_SHIFT) | (SVDProblemType)digits[2]) << PyLong_SHIFT) | (SVDProblemType)digits[1]) << PyLong_SHIFT) | (SVDProblemType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (SVDProblemType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(SVDProblemType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDProblemType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(SVDProblemType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDProblemType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (SVDProblemType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(SVDProblemType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(SVDProblemType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(SVDProblemType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDProblemType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDProblemType) - 1 > 2 * PyLong_SHIFT) {
                            return (SVDProblemType) (((SVDProblemType)-1)*(((((SVDProblemType)digits[1]) << PyLong_SHIFT) | (SVDProblemType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(SVDProblemType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDProblemType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDProblemType) - 1 > 2 * PyLong_SHIFT) {
                            return (SVDProblemType) ((((((SVDProblemType)digits[1]) << PyLong_SHIFT) | (SVDProblemType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(SVDProblemType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDProblemType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDProblemType) - 1 > 3 * PyLong_SHIFT) {
                            return (SVDProblemType) (((SVDProblemType)-1)*(((((((SVDProblemType)digits[2]) << PyLong_SHIFT) | (SVDProblemType)digits[1]) << PyLong_SHIFT) | (SVDProblemType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(SVDProblemType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDProblemType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDProblemType) - 1 > 3 * PyLong_SHIFT) {
                            return (SVDProblemType) ((((((((SVDProblemType)digits[2]) << PyLong_SHIFT) | (SVDProblemType)digits[1]) << PyLong_SHIFT) | (SVDProblemType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(SVDProblemType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDProblemType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDProblemType) - 1 > 4 * PyLong_SHIFT) {
                            return (SVDProblemType) (((SVDProblemType)-1)*(((((((((SVDProblemType)digits[3]) << PyLong_SHIFT) | (SVDProblemType)digits[2]) << PyLong_SHIFT) | (SVDProblemType)digits[1]) << PyLong_SHIFT) | (SVDProblemType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(SVDProblemType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDProblemType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDProblemType) - 1 > 4 * PyLong_SHIFT) {
                            return (SVDProblemType) ((((((((((SVDProblemType)digits[3]) << PyLong_SHIFT) | (SVDProblemType)digits[2]) << PyLong_SHIFT) | (SVDProblemType)digits[1]) << PyLong_SHIFT) | (SVDProblemType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(SVDProblemType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDProblemType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(SVDProblemType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDProblemType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            SVDProblemType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (SVDProblemType) -1;
        }
    } else {
        SVDProblemType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (SVDProblemType) -1;
        val = __Pyx_PyInt_As_SVDProblemType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to SVDProblemType");
    return (SVDProblemType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to SVDProblemType");
    return (SVDProblemType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE SVDWhich __Pyx_PyInt_As_SVDWhich(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const SVDWhich neg_one = (SVDWhich) -1, const_zero = (SVDWhich) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(SVDWhich) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(SVDWhich, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (SVDWhich) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (SVDWhich) 0;
                case  1: __PYX_VERIFY_RETURN_INT(SVDWhich, digit, digits[0])
                case 2:
                    if (8 * sizeof(SVDWhich) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDWhich, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDWhich) >= 2 * PyLong_SHIFT) {
                            return (SVDWhich) (((((SVDWhich)digits[1]) << PyLong_SHIFT) | (SVDWhich)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(SVDWhich) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDWhich, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDWhich) >= 3 * PyLong_SHIFT) {
                            return (SVDWhich) (((((((SVDWhich)digits[2]) << PyLong_SHIFT) | (SVDWhich)digits[1]) << PyLong_SHIFT) | (SVDWhich)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(SVDWhich) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDWhich, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDWhich) >= 4 * PyLong_SHIFT) {
                            return (SVDWhich) (((((((((SVDWhich)digits[3]) << PyLong_SHIFT) | (SVDWhich)digits[2]) << PyLong_SHIFT) | (SVDWhich)digits[1]) << PyLong_SHIFT) | (SVDWhich)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (SVDWhich) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(SVDWhich) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDWhich, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(SVDWhich) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDWhich, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (SVDWhich) 0;
                case -1: __PYX_VERIFY_RETURN_INT(SVDWhich, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(SVDWhich,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(SVDWhich) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDWhich, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDWhich) - 1 > 2 * PyLong_SHIFT) {
                            return (SVDWhich) (((SVDWhich)-1)*(((((SVDWhich)digits[1]) << PyLong_SHIFT) | (SVDWhich)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(SVDWhich) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDWhich, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDWhich) - 1 > 2 * PyLong_SHIFT) {
                            return (SVDWhich) ((((((SVDWhich)digits[1]) << PyLong_SHIFT) | (SVDWhich)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(SVDWhich) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDWhich, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDWhich) - 1 > 3 * PyLong_SHIFT) {
                            return (SVDWhich) (((SVDWhich)-1)*(((((((SVDWhich)digits[2]) << PyLong_SHIFT) | (SVDWhich)digits[1]) << PyLong_SHIFT) | (SVDWhich)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(SVDWhich) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDWhich, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDWhich) - 1 > 3 * PyLong_SHIFT) {
                            return (SVDWhich) ((((((((SVDWhich)digits[2]) << PyLong_SHIFT) | (SVDWhich)digits[1]) << PyLong_SHIFT) | (SVDWhich)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(SVDWhich) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDWhich, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDWhich) - 1 > 4 * PyLong_SHIFT) {
                            return (SVDWhich) (((SVDWhich)-1)*(((((((((SVDWhich)digits[3]) << PyLong_SHIFT) | (SVDWhich)digits[2]) << PyLong_SHIFT) | (SVDWhich)digits[1]) << PyLong_SHIFT) | (SVDWhich)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(SVDWhich) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDWhich, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDWhich) - 1 > 4 * PyLong_SHIFT) {
                            return (SVDWhich) ((((((((((SVDWhich)digits[3]) << PyLong_SHIFT) | (SVDWhich)digits[2]) << PyLong_SHIFT) | (SVDWhich)digits[1]) << PyLong_SHIFT) | (SVDWhich)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(SVDWhich) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDWhich, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(SVDWhich) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDWhich, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            SVDWhich val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (SVDWhich) -1;
        }
    } else {
        SVDWhich val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (SVDWhich) -1;
        val = __Pyx_PyInt_As_SVDWhich(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to SVDWhich");
    return (SVDWhich) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to SVDWhich");
    return (SVDWhich) -1;
}

/* CIntFromPy */
static CYTHON_INLINE SVDConv __Pyx_PyInt_As_SVDConv(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const SVDConv neg_one = (SVDConv) -1, const_zero = (SVDConv) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(SVDConv) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(SVDConv, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (SVDConv) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (SVDConv) 0;
                case  1: __PYX_VERIFY_RETURN_INT(SVDConv, digit, digits[0])
                case 2:
                    if (8 * sizeof(SVDConv) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConv, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConv) >= 2 * PyLong_SHIFT) {
                            return (SVDConv) (((((SVDConv)digits[1]) << PyLong_SHIFT) | (SVDConv)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(SVDConv) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConv, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConv) >= 3 * PyLong_SHIFT) {
                            return (SVDConv) (((((((SVDConv)digits[2]) << PyLong_SHIFT) | (SVDConv)digits[1]) << PyLong_SHIFT) | (SVDConv)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(SVDConv) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConv, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConv) >= 4 * PyLong_SHIFT) {
                            return (SVDConv) (((((((((SVDConv)digits[3]) << PyLong_SHIFT) | (SVDConv)digits[2]) << PyLong_SHIFT) | (SVDConv)digits[1]) << PyLong_SHIFT) | (SVDConv)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (SVDConv) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(SVDConv) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDConv, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(SVDConv) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDConv, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (SVDConv) 0;
                case -1: __PYX_VERIFY_RETURN_INT(SVDConv, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(SVDConv,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(SVDConv) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConv, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConv) - 1 > 2 * PyLong_SHIFT) {
                            return (SVDConv) (((SVDConv)-1)*(((((SVDConv)digits[1]) << PyLong_SHIFT) | (SVDConv)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(SVDConv) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConv, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConv) - 1 > 2 * PyLong_SHIFT) {
                            return (SVDConv) ((((((SVDConv)digits[1]) << PyLong_SHIFT) | (SVDConv)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(SVDConv) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConv, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConv) - 1 > 3 * PyLong_SHIFT) {
                            return (SVDConv) (((SVDConv)-1)*(((((((SVDConv)digits[2]) << PyLong_SHIFT) | (SVDConv)digits[1]) << PyLong_SHIFT) | (SVDConv)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(SVDConv) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConv, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConv) - 1 > 3 * PyLong_SHIFT) {
                            return (SVDConv) ((((((((SVDConv)digits[2]) << PyLong_SHIFT) | (SVDConv)digits[1]) << PyLong_SHIFT) | (SVDConv)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(SVDConv) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConv, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConv) - 1 > 4 * PyLong_SHIFT) {
                            return (SVDConv) (((SVDConv)-1)*(((((((((SVDConv)digits[3]) << PyLong_SHIFT) | (SVDConv)digits[2]) << PyLong_SHIFT) | (SVDConv)digits[1]) << PyLong_SHIFT) | (SVDConv)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(SVDConv) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDConv, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDConv) - 1 > 4 * PyLong_SHIFT) {
                            return (SVDConv) ((((((((((SVDConv)digits[3]) << PyLong_SHIFT) | (SVDConv)digits[2]) << PyLong_SHIFT) | (SVDConv)digits[1]) << PyLong_SHIFT) | (SVDConv)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(SVDConv) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDConv, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(SVDConv) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDConv, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            SVDConv val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (SVDConv) -1;
        }
    } else {
        SVDConv val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (SVDConv) -1;
        val = __Pyx_PyInt_As_SVDConv(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to SVDConv");
    return (SVDConv) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to SVDConv");
    return (SVDConv) -1;
}

/* CIntFromPy */
static CYTHON_INLINE SVDErrorType __Pyx_PyInt_As_SVDErrorType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const SVDErrorType neg_one = (SVDErrorType) -1, const_zero = (SVDErrorType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(SVDErrorType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(SVDErrorType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (SVDErrorType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (SVDErrorType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(SVDErrorType, digit, digits[0])
                case 2:
                    if (8 * sizeof(SVDErrorType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDErrorType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDErrorType) >= 2 * PyLong_SHIFT) {
                            return (SVDErrorType) (((((SVDErrorType)digits[1]) << PyLong_SHIFT) | (SVDErrorType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(SVDErrorType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDErrorType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDErrorType) >= 3 * PyLong_SHIFT) {
                            return (SVDErrorType) (((((((SVDErrorType)digits[2]) << PyLong_SHIFT) | (SVDErrorType)digits[1]) << PyLong_SHIFT) | (SVDErrorType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(SVDErrorType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDErrorType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDErrorType) >= 4 * PyLong_SHIFT) {
                            return (SVDErrorType) (((((((((SVDErrorType)digits[3]) << PyLong_SHIFT) | (SVDErrorType)digits[2]) << PyLong_SHIFT) | (SVDErrorType)digits[1]) << PyLong_SHIFT) | (SVDErrorType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (SVDErrorType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(SVDErrorType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDErrorType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(SVDErrorType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDErrorType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (SVDErrorType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(SVDErrorType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(SVDErrorType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(SVDErrorType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDErrorType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDErrorType) - 1 > 2 * PyLong_SHIFT) {
                            return (SVDErrorType) (((SVDErrorType)-1)*(((((SVDErrorType)digits[1]) << PyLong_SHIFT) | (SVDErrorType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(SVDErrorType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDErrorType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDErrorType) - 1 > 2 * PyLong_SHIFT) {
                            return (SVDErrorType) ((((((SVDErrorType)digits[1]) << PyLong_SHIFT) | (SVDErrorType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(SVDErrorType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDErrorType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDErrorType) - 1 > 3 * PyLong_SHIFT) {
                            return (SVDErrorType) (((SVDErrorType)-1)*(((((((SVDErrorType)digits[2]) << PyLong_SHIFT) | (SVDErrorType)digits[1]) << PyLong_SHIFT) | (SVDErrorType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(SVDErrorType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDErrorType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDErrorType) - 1 > 3 * PyLong_SHIFT) {
                            return (SVDErrorType) ((((((((SVDErrorType)digits[2]) << PyLong_SHIFT) | (SVDErrorType)digits[1]) << PyLong_SHIFT) | (SVDErrorType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(SVDErrorType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDErrorType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDErrorType) - 1 > 4 * PyLong_SHIFT) {
                            return (SVDErrorType) (((SVDErrorType)-1)*(((((((((SVDErrorType)digits[3]) << PyLong_SHIFT) | (SVDErrorType)digits[2]) << PyLong_SHIFT) | (SVDErrorType)digits[1]) << PyLong_SHIFT) | (SVDErrorType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(SVDErrorType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDErrorType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDErrorType) - 1 > 4 * PyLong_SHIFT) {
                            return (SVDErrorType) ((((((((((SVDErrorType)digits[3]) << PyLong_SHIFT) | (SVDErrorType)digits[2]) << PyLong_SHIFT) | (SVDErrorType)digits[1]) << PyLong_SHIFT) | (SVDErrorType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(SVDErrorType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDErrorType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(SVDErrorType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDErrorType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            SVDErrorType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (SVDErrorType) -1;
        }
    } else {
        SVDErrorType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (SVDErrorType) -1;
        val = __Pyx_PyInt_As_SVDErrorType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to SVDErrorType");
    return (SVDErrorType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to SVDErrorType");
    return (SVDErrorType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE SVDTRLanczosGBidiag __Pyx_PyInt_As_SVDTRLanczosGBidiag(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const SVDTRLanczosGBidiag neg_one = (SVDTRLanczosGBidiag) -1, const_zero = (SVDTRLanczosGBidiag) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(SVDTRLanczosGBidiag) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(SVDTRLanczosGBidiag, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (SVDTRLanczosGBidiag) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (SVDTRLanczosGBidiag) 0;
                case  1: __PYX_VERIFY_RETURN_INT(SVDTRLanczosGBidiag, digit, digits[0])
                case 2:
                    if (8 * sizeof(SVDTRLanczosGBidiag) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDTRLanczosGBidiag, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDTRLanczosGBidiag) >= 2 * PyLong_SHIFT) {
                            return (SVDTRLanczosGBidiag) (((((SVDTRLanczosGBidiag)digits[1]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(SVDTRLanczosGBidiag) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDTRLanczosGBidiag, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDTRLanczosGBidiag) >= 3 * PyLong_SHIFT) {
                            return (SVDTRLanczosGBidiag) (((((((SVDTRLanczosGBidiag)digits[2]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[1]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(SVDTRLanczosGBidiag) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDTRLanczosGBidiag, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDTRLanczosGBidiag) >= 4 * PyLong_SHIFT) {
                            return (SVDTRLanczosGBidiag) (((((((((SVDTRLanczosGBidiag)digits[3]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[2]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[1]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (SVDTRLanczosGBidiag) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(SVDTRLanczosGBidiag) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDTRLanczosGBidiag, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(SVDTRLanczosGBidiag) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDTRLanczosGBidiag, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (SVDTRLanczosGBidiag) 0;
                case -1: __PYX_VERIFY_RETURN_INT(SVDTRLanczosGBidiag, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(SVDTRLanczosGBidiag,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(SVDTRLanczosGBidiag) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDTRLanczosGBidiag, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDTRLanczosGBidiag) - 1 > 2 * PyLong_SHIFT) {
                            return (SVDTRLanczosGBidiag) (((SVDTRLanczosGBidiag)-1)*(((((SVDTRLanczosGBidiag)digits[1]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(SVDTRLanczosGBidiag) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDTRLanczosGBidiag, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDTRLanczosGBidiag) - 1 > 2 * PyLong_SHIFT) {
                            return (SVDTRLanczosGBidiag) ((((((SVDTRLanczosGBidiag)digits[1]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(SVDTRLanczosGBidiag) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDTRLanczosGBidiag, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDTRLanczosGBidiag) - 1 > 3 * PyLong_SHIFT) {
                            return (SVDTRLanczosGBidiag) (((SVDTRLanczosGBidiag)-1)*(((((((SVDTRLanczosGBidiag)digits[2]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[1]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(SVDTRLanczosGBidiag) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDTRLanczosGBidiag, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDTRLanczosGBidiag) - 1 > 3 * PyLong_SHIFT) {
                            return (SVDTRLanczosGBidiag) ((((((((SVDTRLanczosGBidiag)digits[2]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[1]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(SVDTRLanczosGBidiag) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDTRLanczosGBidiag, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDTRLanczosGBidiag) - 1 > 4 * PyLong_SHIFT) {
                            return (SVDTRLanczosGBidiag) (((SVDTRLanczosGBidiag)-1)*(((((((((SVDTRLanczosGBidiag)digits[3]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[2]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[1]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(SVDTRLanczosGBidiag) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(SVDTRLanczosGBidiag, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(SVDTRLanczosGBidiag) - 1 > 4 * PyLong_SHIFT) {
                            return (SVDTRLanczosGBidiag) ((((((((((SVDTRLanczosGBidiag)digits[3]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[2]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[1]) << PyLong_SHIFT) | (SVDTRLanczosGBidiag)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(SVDTRLanczosGBidiag) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDTRLanczosGBidiag, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(SVDTRLanczosGBidiag) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(SVDTRLanczosGBidiag, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            SVDTRLanczosGBidiag val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (SVDTRLanczosGBidiag) -1;
        }
    } else {
        SVDTRLanczosGBidiag val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (SVDTRLanczosGBidiag) -1;
        val = __Pyx_PyInt_As_SVDTRLanczosGBidiag(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to SVDTRLanczosGBidiag");
    return (SVDTRLanczosGBidiag) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to SVDTRLanczosGBidiag");
    return (SVDTRLanczosGBidiag) -1;
}

/* CIntFromPy */
static CYTHON_INLINE PEPBasis __Pyx_PyInt_As_PEPBasis(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPBasis neg_one = (PEPBasis) -1, const_zero = (PEPBasis) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(PEPBasis) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(PEPBasis, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (PEPBasis) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPBasis) 0;
                case  1: __PYX_VERIFY_RETURN_INT(PEPBasis, digit, digits[0])
                case 2:
                    if (8 * sizeof(PEPBasis) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPBasis, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPBasis) >= 2 * PyLong_SHIFT) {
                            return (PEPBasis) (((((PEPBasis)digits[1]) << PyLong_SHIFT) | (PEPBasis)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPBasis) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPBasis, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPBasis) >= 3 * PyLong_SHIFT) {
                            return (PEPBasis) (((((((PEPBasis)digits[2]) << PyLong_SHIFT) | (PEPBasis)digits[1]) << PyLong_SHIFT) | (PEPBasis)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPBasis) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPBasis, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPBasis) >= 4 * PyLong_SHIFT) {
                            return (PEPBasis) (((((((((PEPBasis)digits[3]) << PyLong_SHIFT) | (PEPBasis)digits[2]) << PyLong_SHIFT) | (PEPBasis)digits[1]) << PyLong_SHIFT) | (PEPBasis)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (PEPBasis) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(PEPBasis) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPBasis, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPBasis) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPBasis, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPBasis) 0;
                case -1: __PYX_VERIFY_RETURN_INT(PEPBasis, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(PEPBasis,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(PEPBasis) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPBasis, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPBasis) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPBasis) (((PEPBasis)-1)*(((((PEPBasis)digits[1]) << PyLong_SHIFT) | (PEPBasis)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(PEPBasis) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPBasis, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPBasis) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPBasis) ((((((PEPBasis)digits[1]) << PyLong_SHIFT) | (PEPBasis)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(PEPBasis) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPBasis, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPBasis) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPBasis) (((PEPBasis)-1)*(((((((PEPBasis)digits[2]) << PyLong_SHIFT) | (PEPBasis)digits[1]) << PyLong_SHIFT) | (PEPBasis)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPBasis) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPBasis, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPBasis) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPBasis) ((((((((PEPBasis)digits[2]) << PyLong_SHIFT) | (PEPBasis)digits[1]) << PyLong_SHIFT) | (PEPBasis)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(PEPBasis) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPBasis, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPBasis) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPBasis) (((PEPBasis)-1)*(((((((((PEPBasis)digits[3]) << PyLong_SHIFT) | (PEPBasis)digits[2]) << PyLong_SHIFT) | (PEPBasis)digits[1]) << PyLong_SHIFT) | (PEPBasis)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPBasis) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPBasis, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPBasis) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPBasis) ((((((((((PEPBasis)digits[3]) << PyLong_SHIFT) | (PEPBasis)digits[2]) << PyLong_SHIFT) | (PEPBasis)digits[1]) << PyLong_SHIFT) | (PEPBasis)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(PEPBasis) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPBasis, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPBasis) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPBasis, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            PEPBasis val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (PEPBasis) -1;
        }
    } else {
        PEPBasis val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (PEPBasis) -1;
        val = __Pyx_PyInt_As_PEPBasis(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to PEPBasis");
    return (PEPBasis) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to PEPBasis");
    return (PEPBasis) -1;
}

/* CIntFromPy */
static CYTHON_INLINE PEPProblemType __Pyx_PyInt_As_PEPProblemType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPProblemType neg_one = (PEPProblemType) -1, const_zero = (PEPProblemType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(PEPProblemType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(PEPProblemType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (PEPProblemType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPProblemType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(PEPProblemType, digit, digits[0])
                case 2:
                    if (8 * sizeof(PEPProblemType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPProblemType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPProblemType) >= 2 * PyLong_SHIFT) {
                            return (PEPProblemType) (((((PEPProblemType)digits[1]) << PyLong_SHIFT) | (PEPProblemType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPProblemType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPProblemType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPProblemType) >= 3 * PyLong_SHIFT) {
                            return (PEPProblemType) (((((((PEPProblemType)digits[2]) << PyLong_SHIFT) | (PEPProblemType)digits[1]) << PyLong_SHIFT) | (PEPProblemType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPProblemType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPProblemType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPProblemType) >= 4 * PyLong_SHIFT) {
                            return (PEPProblemType) (((((((((PEPProblemType)digits[3]) << PyLong_SHIFT) | (PEPProblemType)digits[2]) << PyLong_SHIFT) | (PEPProblemType)digits[1]) << PyLong_SHIFT) | (PEPProblemType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (PEPProblemType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(PEPProblemType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPProblemType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPProblemType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPProblemType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPProblemType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(PEPProblemType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(PEPProblemType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(PEPProblemType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPProblemType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPProblemType) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPProblemType) (((PEPProblemType)-1)*(((((PEPProblemType)digits[1]) << PyLong_SHIFT) | (PEPProblemType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(PEPProblemType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPProblemType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPProblemType) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPProblemType) ((((((PEPProblemType)digits[1]) << PyLong_SHIFT) | (PEPProblemType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(PEPProblemType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPProblemType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPProblemType) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPProblemType) (((PEPProblemType)-1)*(((((((PEPProblemType)digits[2]) << PyLong_SHIFT) | (PEPProblemType)digits[1]) << PyLong_SHIFT) | (PEPProblemType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPProblemType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPProblemType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPProblemType) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPProblemType) ((((((((PEPProblemType)digits[2]) << PyLong_SHIFT) | (PEPProblemType)digits[1]) << PyLong_SHIFT) | (PEPProblemType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(PEPProblemType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPProblemType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPProblemType) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPProblemType) (((PEPProblemType)-1)*(((((((((PEPProblemType)digits[3]) << PyLong_SHIFT) | (PEPProblemType)digits[2]) << PyLong_SHIFT) | (PEPProblemType)digits[1]) << PyLong_SHIFT) | (PEPProblemType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPProblemType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPProblemType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPProblemType) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPProblemType) ((((((((((PEPProblemType)digits[3]) << PyLong_SHIFT) | (PEPProblemType)digits[2]) << PyLong_SHIFT) | (PEPProblemType)digits[1]) << PyLong_SHIFT) | (PEPProblemType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(PEPProblemType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPProblemType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPProblemType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPProblemType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            PEPProblemType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (PEPProblemType) -1;
        }
    } else {
        PEPProblemType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (PEPProblemType) -1;
        val = __Pyx_PyInt_As_PEPProblemType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to PEPProblemType");
    return (PEPProblemType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to PEPProblemType");
    return (PEPProblemType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE PEPWhich __Pyx_PyInt_As_PEPWhich(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPWhich neg_one = (PEPWhich) -1, const_zero = (PEPWhich) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(PEPWhich) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(PEPWhich, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (PEPWhich) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPWhich) 0;
                case  1: __PYX_VERIFY_RETURN_INT(PEPWhich, digit, digits[0])
                case 2:
                    if (8 * sizeof(PEPWhich) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPWhich, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPWhich) >= 2 * PyLong_SHIFT) {
                            return (PEPWhich) (((((PEPWhich)digits[1]) << PyLong_SHIFT) | (PEPWhich)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPWhich) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPWhich, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPWhich) >= 3 * PyLong_SHIFT) {
                            return (PEPWhich) (((((((PEPWhich)digits[2]) << PyLong_SHIFT) | (PEPWhich)digits[1]) << PyLong_SHIFT) | (PEPWhich)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPWhich) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPWhich, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPWhich) >= 4 * PyLong_SHIFT) {
                            return (PEPWhich) (((((((((PEPWhich)digits[3]) << PyLong_SHIFT) | (PEPWhich)digits[2]) << PyLong_SHIFT) | (PEPWhich)digits[1]) << PyLong_SHIFT) | (PEPWhich)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (PEPWhich) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(PEPWhich) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPWhich, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPWhich) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPWhich, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPWhich) 0;
                case -1: __PYX_VERIFY_RETURN_INT(PEPWhich, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(PEPWhich,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(PEPWhich) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPWhich, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPWhich) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPWhich) (((PEPWhich)-1)*(((((PEPWhich)digits[1]) << PyLong_SHIFT) | (PEPWhich)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(PEPWhich) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPWhich, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPWhich) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPWhich) ((((((PEPWhich)digits[1]) << PyLong_SHIFT) | (PEPWhich)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(PEPWhich) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPWhich, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPWhich) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPWhich) (((PEPWhich)-1)*(((((((PEPWhich)digits[2]) << PyLong_SHIFT) | (PEPWhich)digits[1]) << PyLong_SHIFT) | (PEPWhich)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPWhich) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPWhich, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPWhich) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPWhich) ((((((((PEPWhich)digits[2]) << PyLong_SHIFT) | (PEPWhich)digits[1]) << PyLong_SHIFT) | (PEPWhich)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(PEPWhich) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPWhich, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPWhich) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPWhich) (((PEPWhich)-1)*(((((((((PEPWhich)digits[3]) << PyLong_SHIFT) | (PEPWhich)digits[2]) << PyLong_SHIFT) | (PEPWhich)digits[1]) << PyLong_SHIFT) | (PEPWhich)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPWhich) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPWhich, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPWhich) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPWhich) ((((((((((PEPWhich)digits[3]) << PyLong_SHIFT) | (PEPWhich)digits[2]) << PyLong_SHIFT) | (PEPWhich)digits[1]) << PyLong_SHIFT) | (PEPWhich)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(PEPWhich) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPWhich, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPWhich) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPWhich, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            PEPWhich val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (PEPWhich) -1;
        }
    } else {
        PEPWhich val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (PEPWhich) -1;
        val = __Pyx_PyInt_As_PEPWhich(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to PEPWhich");
    return (PEPWhich) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to PEPWhich");
    return (PEPWhich) -1;
}

/* CIntFromPy */
static CYTHON_INLINE PEPConv __Pyx_PyInt_As_PEPConv(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPConv neg_one = (PEPConv) -1, const_zero = (PEPConv) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(PEPConv) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(PEPConv, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (PEPConv) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPConv) 0;
                case  1: __PYX_VERIFY_RETURN_INT(PEPConv, digit, digits[0])
                case 2:
                    if (8 * sizeof(PEPConv) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConv, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConv) >= 2 * PyLong_SHIFT) {
                            return (PEPConv) (((((PEPConv)digits[1]) << PyLong_SHIFT) | (PEPConv)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPConv) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConv, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConv) >= 3 * PyLong_SHIFT) {
                            return (PEPConv) (((((((PEPConv)digits[2]) << PyLong_SHIFT) | (PEPConv)digits[1]) << PyLong_SHIFT) | (PEPConv)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPConv) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConv, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConv) >= 4 * PyLong_SHIFT) {
                            return (PEPConv) (((((((((PEPConv)digits[3]) << PyLong_SHIFT) | (PEPConv)digits[2]) << PyLong_SHIFT) | (PEPConv)digits[1]) << PyLong_SHIFT) | (PEPConv)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (PEPConv) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(PEPConv) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPConv, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPConv) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPConv, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPConv) 0;
                case -1: __PYX_VERIFY_RETURN_INT(PEPConv, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(PEPConv,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(PEPConv) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConv, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConv) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPConv) (((PEPConv)-1)*(((((PEPConv)digits[1]) << PyLong_SHIFT) | (PEPConv)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(PEPConv) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConv, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConv) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPConv) ((((((PEPConv)digits[1]) << PyLong_SHIFT) | (PEPConv)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(PEPConv) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConv, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConv) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPConv) (((PEPConv)-1)*(((((((PEPConv)digits[2]) << PyLong_SHIFT) | (PEPConv)digits[1]) << PyLong_SHIFT) | (PEPConv)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPConv) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConv, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConv) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPConv) ((((((((PEPConv)digits[2]) << PyLong_SHIFT) | (PEPConv)digits[1]) << PyLong_SHIFT) | (PEPConv)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(PEPConv) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConv, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConv) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPConv) (((PEPConv)-1)*(((((((((PEPConv)digits[3]) << PyLong_SHIFT) | (PEPConv)digits[2]) << PyLong_SHIFT) | (PEPConv)digits[1]) << PyLong_SHIFT) | (PEPConv)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPConv) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPConv, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPConv) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPConv) ((((((((((PEPConv)digits[3]) << PyLong_SHIFT) | (PEPConv)digits[2]) << PyLong_SHIFT) | (PEPConv)digits[1]) << PyLong_SHIFT) | (PEPConv)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(PEPConv) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPConv, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPConv) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPConv, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            PEPConv val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (PEPConv) -1;
        }
    } else {
        PEPConv val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (PEPConv) -1;
        val = __Pyx_PyInt_As_PEPConv(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to PEPConv");
    return (PEPConv) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to PEPConv");
    return (PEPConv) -1;
}

/* CIntFromPy */
static CYTHON_INLINE PEPRefine __Pyx_PyInt_As_PEPRefine(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPRefine neg_one = (PEPRefine) -1, const_zero = (PEPRefine) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(PEPRefine) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(PEPRefine, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (PEPRefine) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPRefine) 0;
                case  1: __PYX_VERIFY_RETURN_INT(PEPRefine, digit, digits[0])
                case 2:
                    if (8 * sizeof(PEPRefine) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefine, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefine) >= 2 * PyLong_SHIFT) {
                            return (PEPRefine) (((((PEPRefine)digits[1]) << PyLong_SHIFT) | (PEPRefine)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPRefine) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefine, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefine) >= 3 * PyLong_SHIFT) {
                            return (PEPRefine) (((((((PEPRefine)digits[2]) << PyLong_SHIFT) | (PEPRefine)digits[1]) << PyLong_SHIFT) | (PEPRefine)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPRefine) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefine, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefine) >= 4 * PyLong_SHIFT) {
                            return (PEPRefine) (((((((((PEPRefine)digits[3]) << PyLong_SHIFT) | (PEPRefine)digits[2]) << PyLong_SHIFT) | (PEPRefine)digits[1]) << PyLong_SHIFT) | (PEPRefine)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (PEPRefine) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(PEPRefine) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPRefine, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPRefine) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPRefine, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPRefine) 0;
                case -1: __PYX_VERIFY_RETURN_INT(PEPRefine, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(PEPRefine,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(PEPRefine) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefine, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefine) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPRefine) (((PEPRefine)-1)*(((((PEPRefine)digits[1]) << PyLong_SHIFT) | (PEPRefine)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(PEPRefine) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefine, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefine) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPRefine) ((((((PEPRefine)digits[1]) << PyLong_SHIFT) | (PEPRefine)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(PEPRefine) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefine, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefine) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPRefine) (((PEPRefine)-1)*(((((((PEPRefine)digits[2]) << PyLong_SHIFT) | (PEPRefine)digits[1]) << PyLong_SHIFT) | (PEPRefine)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPRefine) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefine, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefine) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPRefine) ((((((((PEPRefine)digits[2]) << PyLong_SHIFT) | (PEPRefine)digits[1]) << PyLong_SHIFT) | (PEPRefine)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(PEPRefine) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefine, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefine) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPRefine) (((PEPRefine)-1)*(((((((((PEPRefine)digits[3]) << PyLong_SHIFT) | (PEPRefine)digits[2]) << PyLong_SHIFT) | (PEPRefine)digits[1]) << PyLong_SHIFT) | (PEPRefine)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPRefine) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefine, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefine) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPRefine) ((((((((((PEPRefine)digits[3]) << PyLong_SHIFT) | (PEPRefine)digits[2]) << PyLong_SHIFT) | (PEPRefine)digits[1]) << PyLong_SHIFT) | (PEPRefine)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(PEPRefine) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPRefine, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPRefine) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPRefine, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            PEPRefine val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (PEPRefine) -1;
        }
    } else {
        PEPRefine val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (PEPRefine) -1;
        val = __Pyx_PyInt_As_PEPRefine(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to PEPRefine");
    return (PEPRefine) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to PEPRefine");
    return (PEPRefine) -1;
}

/* CIntFromPy */
static CYTHON_INLINE PEPRefineScheme __Pyx_PyInt_As_PEPRefineScheme(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPRefineScheme neg_one = (PEPRefineScheme) -1, const_zero = (PEPRefineScheme) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(PEPRefineScheme) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(PEPRefineScheme, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (PEPRefineScheme) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPRefineScheme) 0;
                case  1: __PYX_VERIFY_RETURN_INT(PEPRefineScheme, digit, digits[0])
                case 2:
                    if (8 * sizeof(PEPRefineScheme) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefineScheme, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefineScheme) >= 2 * PyLong_SHIFT) {
                            return (PEPRefineScheme) (((((PEPRefineScheme)digits[1]) << PyLong_SHIFT) | (PEPRefineScheme)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPRefineScheme) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefineScheme, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefineScheme) >= 3 * PyLong_SHIFT) {
                            return (PEPRefineScheme) (((((((PEPRefineScheme)digits[2]) << PyLong_SHIFT) | (PEPRefineScheme)digits[1]) << PyLong_SHIFT) | (PEPRefineScheme)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPRefineScheme) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefineScheme, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefineScheme) >= 4 * PyLong_SHIFT) {
                            return (PEPRefineScheme) (((((((((PEPRefineScheme)digits[3]) << PyLong_SHIFT) | (PEPRefineScheme)digits[2]) << PyLong_SHIFT) | (PEPRefineScheme)digits[1]) << PyLong_SHIFT) | (PEPRefineScheme)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (PEPRefineScheme) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(PEPRefineScheme) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPRefineScheme, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPRefineScheme) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPRefineScheme, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPRefineScheme) 0;
                case -1: __PYX_VERIFY_RETURN_INT(PEPRefineScheme, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(PEPRefineScheme,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(PEPRefineScheme) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefineScheme, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefineScheme) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPRefineScheme) (((PEPRefineScheme)-1)*(((((PEPRefineScheme)digits[1]) << PyLong_SHIFT) | (PEPRefineScheme)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(PEPRefineScheme) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefineScheme, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefineScheme) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPRefineScheme) ((((((PEPRefineScheme)digits[1]) << PyLong_SHIFT) | (PEPRefineScheme)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(PEPRefineScheme) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefineScheme, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefineScheme) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPRefineScheme) (((PEPRefineScheme)-1)*(((((((PEPRefineScheme)digits[2]) << PyLong_SHIFT) | (PEPRefineScheme)digits[1]) << PyLong_SHIFT) | (PEPRefineScheme)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPRefineScheme) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefineScheme, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefineScheme) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPRefineScheme) ((((((((PEPRefineScheme)digits[2]) << PyLong_SHIFT) | (PEPRefineScheme)digits[1]) << PyLong_SHIFT) | (PEPRefineScheme)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(PEPRefineScheme) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefineScheme, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefineScheme) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPRefineScheme) (((PEPRefineScheme)-1)*(((((((((PEPRefineScheme)digits[3]) << PyLong_SHIFT) | (PEPRefineScheme)digits[2]) << PyLong_SHIFT) | (PEPRefineScheme)digits[1]) << PyLong_SHIFT) | (PEPRefineScheme)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPRefineScheme) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPRefineScheme, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPRefineScheme) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPRefineScheme) ((((((((((PEPRefineScheme)digits[3]) << PyLong_SHIFT) | (PEPRefineScheme)digits[2]) << PyLong_SHIFT) | (PEPRefineScheme)digits[1]) << PyLong_SHIFT) | (PEPRefineScheme)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(PEPRefineScheme) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPRefineScheme, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPRefineScheme) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPRefineScheme, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            PEPRefineScheme val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (PEPRefineScheme) -1;
        }
    } else {
        PEPRefineScheme val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (PEPRefineScheme) -1;
        val = __Pyx_PyInt_As_PEPRefineScheme(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to PEPRefineScheme");
    return (PEPRefineScheme) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to PEPRefineScheme");
    return (PEPRefineScheme) -1;
}

/* CIntFromPy */
static CYTHON_INLINE PEPExtract __Pyx_PyInt_As_PEPExtract(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPExtract neg_one = (PEPExtract) -1, const_zero = (PEPExtract) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(PEPExtract) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(PEPExtract, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (PEPExtract) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPExtract) 0;
                case  1: __PYX_VERIFY_RETURN_INT(PEPExtract, digit, digits[0])
                case 2:
                    if (8 * sizeof(PEPExtract) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPExtract, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPExtract) >= 2 * PyLong_SHIFT) {
                            return (PEPExtract) (((((PEPExtract)digits[1]) << PyLong_SHIFT) | (PEPExtract)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPExtract) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPExtract, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPExtract) >= 3 * PyLong_SHIFT) {
                            return (PEPExtract) (((((((PEPExtract)digits[2]) << PyLong_SHIFT) | (PEPExtract)digits[1]) << PyLong_SHIFT) | (PEPExtract)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPExtract) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPExtract, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPExtract) >= 4 * PyLong_SHIFT) {
                            return (PEPExtract) (((((((((PEPExtract)digits[3]) << PyLong_SHIFT) | (PEPExtract)digits[2]) << PyLong_SHIFT) | (PEPExtract)digits[1]) << PyLong_SHIFT) | (PEPExtract)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (PEPExtract) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(PEPExtract) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPExtract, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPExtract) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPExtract, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPExtract) 0;
                case -1: __PYX_VERIFY_RETURN_INT(PEPExtract, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(PEPExtract,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(PEPExtract) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPExtract, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPExtract) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPExtract) (((PEPExtract)-1)*(((((PEPExtract)digits[1]) << PyLong_SHIFT) | (PEPExtract)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(PEPExtract) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPExtract, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPExtract) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPExtract) ((((((PEPExtract)digits[1]) << PyLong_SHIFT) | (PEPExtract)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(PEPExtract) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPExtract, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPExtract) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPExtract) (((PEPExtract)-1)*(((((((PEPExtract)digits[2]) << PyLong_SHIFT) | (PEPExtract)digits[1]) << PyLong_SHIFT) | (PEPExtract)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPExtract) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPExtract, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPExtract) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPExtract) ((((((((PEPExtract)digits[2]) << PyLong_SHIFT) | (PEPExtract)digits[1]) << PyLong_SHIFT) | (PEPExtract)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(PEPExtract) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPExtract, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPExtract) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPExtract) (((PEPExtract)-1)*(((((((((PEPExtract)digits[3]) << PyLong_SHIFT) | (PEPExtract)digits[2]) << PyLong_SHIFT) | (PEPExtract)digits[1]) << PyLong_SHIFT) | (PEPExtract)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPExtract) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPExtract, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPExtract) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPExtract) ((((((((((PEPExtract)digits[3]) << PyLong_SHIFT) | (PEPExtract)digits[2]) << PyLong_SHIFT) | (PEPExtract)digits[1]) << PyLong_SHIFT) | (PEPExtract)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(PEPExtract) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPExtract, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPExtract) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPExtract, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            PEPExtract val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (PEPExtract) -1;
        }
    } else {
        PEPExtract val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (PEPExtract) -1;
        val = __Pyx_PyInt_As_PEPExtract(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to PEPExtract");
    return (PEPExtract) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to PEPExtract");
    return (PEPExtract) -1;
}

/* CIntFromPy */
static CYTHON_INLINE PEPScale __Pyx_PyInt_As_PEPScale(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPScale neg_one = (PEPScale) -1, const_zero = (PEPScale) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(PEPScale) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(PEPScale, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (PEPScale) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPScale) 0;
                case  1: __PYX_VERIFY_RETURN_INT(PEPScale, digit, digits[0])
                case 2:
                    if (8 * sizeof(PEPScale) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPScale, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPScale) >= 2 * PyLong_SHIFT) {
                            return (PEPScale) (((((PEPScale)digits[1]) << PyLong_SHIFT) | (PEPScale)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPScale) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPScale, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPScale) >= 3 * PyLong_SHIFT) {
                            return (PEPScale) (((((((PEPScale)digits[2]) << PyLong_SHIFT) | (PEPScale)digits[1]) << PyLong_SHIFT) | (PEPScale)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPScale) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPScale, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPScale) >= 4 * PyLong_SHIFT) {
                            return (PEPScale) (((((((((PEPScale)digits[3]) << PyLong_SHIFT) | (PEPScale)digits[2]) << PyLong_SHIFT) | (PEPScale)digits[1]) << PyLong_SHIFT) | (PEPScale)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (PEPScale) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(PEPScale) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPScale, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPScale) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPScale, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPScale) 0;
                case -1: __PYX_VERIFY_RETURN_INT(PEPScale, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(PEPScale,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(PEPScale) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPScale, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPScale) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPScale) (((PEPScale)-1)*(((((PEPScale)digits[1]) << PyLong_SHIFT) | (PEPScale)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(PEPScale) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPScale, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPScale) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPScale) ((((((PEPScale)digits[1]) << PyLong_SHIFT) | (PEPScale)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(PEPScale) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPScale, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPScale) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPScale) (((PEPScale)-1)*(((((((PEPScale)digits[2]) << PyLong_SHIFT) | (PEPScale)digits[1]) << PyLong_SHIFT) | (PEPScale)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPScale) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPScale, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPScale) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPScale) ((((((((PEPScale)digits[2]) << PyLong_SHIFT) | (PEPScale)digits[1]) << PyLong_SHIFT) | (PEPScale)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(PEPScale) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPScale, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPScale) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPScale) (((PEPScale)-1)*(((((((((PEPScale)digits[3]) << PyLong_SHIFT) | (PEPScale)digits[2]) << PyLong_SHIFT) | (PEPScale)digits[1]) << PyLong_SHIFT) | (PEPScale)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPScale) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPScale, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPScale) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPScale) ((((((((((PEPScale)digits[3]) << PyLong_SHIFT) | (PEPScale)digits[2]) << PyLong_SHIFT) | (PEPScale)digits[1]) << PyLong_SHIFT) | (PEPScale)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(PEPScale) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPScale, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPScale) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPScale, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            PEPScale val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (PEPScale) -1;
        }
    } else {
        PEPScale val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (PEPScale) -1;
        val = __Pyx_PyInt_As_PEPScale(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to PEPScale");
    return (PEPScale) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to PEPScale");
    return (PEPScale) -1;
}

/* CIntFromPy */
static CYTHON_INLINE PEPErrorType __Pyx_PyInt_As_PEPErrorType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPErrorType neg_one = (PEPErrorType) -1, const_zero = (PEPErrorType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(PEPErrorType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(PEPErrorType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (PEPErrorType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPErrorType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(PEPErrorType, digit, digits[0])
                case 2:
                    if (8 * sizeof(PEPErrorType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPErrorType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPErrorType) >= 2 * PyLong_SHIFT) {
                            return (PEPErrorType) (((((PEPErrorType)digits[1]) << PyLong_SHIFT) | (PEPErrorType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPErrorType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPErrorType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPErrorType) >= 3 * PyLong_SHIFT) {
                            return (PEPErrorType) (((((((PEPErrorType)digits[2]) << PyLong_SHIFT) | (PEPErrorType)digits[1]) << PyLong_SHIFT) | (PEPErrorType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPErrorType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPErrorType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPErrorType) >= 4 * PyLong_SHIFT) {
                            return (PEPErrorType) (((((((((PEPErrorType)digits[3]) << PyLong_SHIFT) | (PEPErrorType)digits[2]) << PyLong_SHIFT) | (PEPErrorType)digits[1]) << PyLong_SHIFT) | (PEPErrorType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (PEPErrorType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(PEPErrorType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPErrorType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPErrorType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPErrorType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPErrorType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(PEPErrorType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(PEPErrorType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(PEPErrorType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPErrorType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPErrorType) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPErrorType) (((PEPErrorType)-1)*(((((PEPErrorType)digits[1]) << PyLong_SHIFT) | (PEPErrorType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(PEPErrorType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPErrorType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPErrorType) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPErrorType) ((((((PEPErrorType)digits[1]) << PyLong_SHIFT) | (PEPErrorType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(PEPErrorType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPErrorType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPErrorType) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPErrorType) (((PEPErrorType)-1)*(((((((PEPErrorType)digits[2]) << PyLong_SHIFT) | (PEPErrorType)digits[1]) << PyLong_SHIFT) | (PEPErrorType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPErrorType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPErrorType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPErrorType) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPErrorType) ((((((((PEPErrorType)digits[2]) << PyLong_SHIFT) | (PEPErrorType)digits[1]) << PyLong_SHIFT) | (PEPErrorType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(PEPErrorType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPErrorType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPErrorType) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPErrorType) (((PEPErrorType)-1)*(((((((((PEPErrorType)digits[3]) << PyLong_SHIFT) | (PEPErrorType)digits[2]) << PyLong_SHIFT) | (PEPErrorType)digits[1]) << PyLong_SHIFT) | (PEPErrorType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPErrorType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPErrorType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPErrorType) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPErrorType) ((((((((((PEPErrorType)digits[3]) << PyLong_SHIFT) | (PEPErrorType)digits[2]) << PyLong_SHIFT) | (PEPErrorType)digits[1]) << PyLong_SHIFT) | (PEPErrorType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(PEPErrorType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPErrorType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPErrorType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPErrorType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            PEPErrorType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (PEPErrorType) -1;
        }
    } else {
        PEPErrorType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (PEPErrorType) -1;
        val = __Pyx_PyInt_As_PEPErrorType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to PEPErrorType");
    return (PEPErrorType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to PEPErrorType");
    return (PEPErrorType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE PEPJDProjection __Pyx_PyInt_As_PEPJDProjection(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPJDProjection neg_one = (PEPJDProjection) -1, const_zero = (PEPJDProjection) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(PEPJDProjection) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(PEPJDProjection, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (PEPJDProjection) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPJDProjection) 0;
                case  1: __PYX_VERIFY_RETURN_INT(PEPJDProjection, digit, digits[0])
                case 2:
                    if (8 * sizeof(PEPJDProjection) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPJDProjection, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPJDProjection) >= 2 * PyLong_SHIFT) {
                            return (PEPJDProjection) (((((PEPJDProjection)digits[1]) << PyLong_SHIFT) | (PEPJDProjection)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPJDProjection) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPJDProjection, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPJDProjection) >= 3 * PyLong_SHIFT) {
                            return (PEPJDProjection) (((((((PEPJDProjection)digits[2]) << PyLong_SHIFT) | (PEPJDProjection)digits[1]) << PyLong_SHIFT) | (PEPJDProjection)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPJDProjection) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPJDProjection, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPJDProjection) >= 4 * PyLong_SHIFT) {
                            return (PEPJDProjection) (((((((((PEPJDProjection)digits[3]) << PyLong_SHIFT) | (PEPJDProjection)digits[2]) << PyLong_SHIFT) | (PEPJDProjection)digits[1]) << PyLong_SHIFT) | (PEPJDProjection)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (PEPJDProjection) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(PEPJDProjection) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPJDProjection, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPJDProjection) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPJDProjection, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPJDProjection) 0;
                case -1: __PYX_VERIFY_RETURN_INT(PEPJDProjection, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(PEPJDProjection,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(PEPJDProjection) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPJDProjection, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPJDProjection) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPJDProjection) (((PEPJDProjection)-1)*(((((PEPJDProjection)digits[1]) << PyLong_SHIFT) | (PEPJDProjection)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(PEPJDProjection) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPJDProjection, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPJDProjection) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPJDProjection) ((((((PEPJDProjection)digits[1]) << PyLong_SHIFT) | (PEPJDProjection)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(PEPJDProjection) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPJDProjection, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPJDProjection) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPJDProjection) (((PEPJDProjection)-1)*(((((((PEPJDProjection)digits[2]) << PyLong_SHIFT) | (PEPJDProjection)digits[1]) << PyLong_SHIFT) | (PEPJDProjection)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPJDProjection) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPJDProjection, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPJDProjection) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPJDProjection) ((((((((PEPJDProjection)digits[2]) << PyLong_SHIFT) | (PEPJDProjection)digits[1]) << PyLong_SHIFT) | (PEPJDProjection)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(PEPJDProjection) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPJDProjection, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPJDProjection) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPJDProjection) (((PEPJDProjection)-1)*(((((((((PEPJDProjection)digits[3]) << PyLong_SHIFT) | (PEPJDProjection)digits[2]) << PyLong_SHIFT) | (PEPJDProjection)digits[1]) << PyLong_SHIFT) | (PEPJDProjection)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPJDProjection) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPJDProjection, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPJDProjection) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPJDProjection) ((((((((((PEPJDProjection)digits[3]) << PyLong_SHIFT) | (PEPJDProjection)digits[2]) << PyLong_SHIFT) | (PEPJDProjection)digits[1]) << PyLong_SHIFT) | (PEPJDProjection)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(PEPJDProjection) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPJDProjection, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPJDProjection) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPJDProjection, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            PEPJDProjection val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (PEPJDProjection) -1;
        }
    } else {
        PEPJDProjection val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (PEPJDProjection) -1;
        val = __Pyx_PyInt_As_PEPJDProjection(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to PEPJDProjection");
    return (PEPJDProjection) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to PEPJDProjection");
    return (PEPJDProjection) -1;
}

/* CIntFromPy */
static CYTHON_INLINE PEPCISSExtraction __Pyx_PyInt_As_PEPCISSExtraction(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const PEPCISSExtraction neg_one = (PEPCISSExtraction) -1, const_zero = (PEPCISSExtraction) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(PEPCISSExtraction) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(PEPCISSExtraction, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (PEPCISSExtraction) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPCISSExtraction) 0;
                case  1: __PYX_VERIFY_RETURN_INT(PEPCISSExtraction, digit, digits[0])
                case 2:
                    if (8 * sizeof(PEPCISSExtraction) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPCISSExtraction, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPCISSExtraction) >= 2 * PyLong_SHIFT) {
                            return (PEPCISSExtraction) (((((PEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPCISSExtraction) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPCISSExtraction, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPCISSExtraction) >= 3 * PyLong_SHIFT) {
                            return (PEPCISSExtraction) (((((((PEPCISSExtraction)digits[2]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPCISSExtraction) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPCISSExtraction, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPCISSExtraction) >= 4 * PyLong_SHIFT) {
                            return (PEPCISSExtraction) (((((((((PEPCISSExtraction)digits[3]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[2]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (PEPCISSExtraction) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(PEPCISSExtraction) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPCISSExtraction, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPCISSExtraction) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPCISSExtraction, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (PEPCISSExtraction) 0;
                case -1: __PYX_VERIFY_RETURN_INT(PEPCISSExtraction, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(PEPCISSExtraction,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(PEPCISSExtraction) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPCISSExtraction, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPCISSExtraction) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPCISSExtraction) (((PEPCISSExtraction)-1)*(((((PEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(PEPCISSExtraction) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPCISSExtraction, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPCISSExtraction) - 1 > 2 * PyLong_SHIFT) {
                            return (PEPCISSExtraction) ((((((PEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(PEPCISSExtraction) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPCISSExtraction, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPCISSExtraction) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPCISSExtraction) (((PEPCISSExtraction)-1)*(((((((PEPCISSExtraction)digits[2]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(PEPCISSExtraction) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPCISSExtraction, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPCISSExtraction) - 1 > 3 * PyLong_SHIFT) {
                            return (PEPCISSExtraction) ((((((((PEPCISSExtraction)digits[2]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(PEPCISSExtraction) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPCISSExtraction, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPCISSExtraction) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPCISSExtraction) (((PEPCISSExtraction)-1)*(((((((((PEPCISSExtraction)digits[3]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[2]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(PEPCISSExtraction) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(PEPCISSExtraction, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(PEPCISSExtraction) - 1 > 4 * PyLong_SHIFT) {
                            return (PEPCISSExtraction) ((((((((((PEPCISSExtraction)digits[3]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[2]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (PEPCISSExtraction)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(PEPCISSExtraction) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPCISSExtraction, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(PEPCISSExtraction) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(PEPCISSExtraction, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            PEPCISSExtraction val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (PEPCISSExtraction) -1;
        }
    } else {
        PEPCISSExtraction val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (PEPCISSExtraction) -1;
        val = __Pyx_PyInt_As_PEPCISSExtraction(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to PEPCISSExtraction");
    return (PEPCISSExtraction) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to PEPCISSExtraction");
    return (PEPCISSExtraction) -1;
}

/* CIntFromPy */
static CYTHON_INLINE NEPProblemType __Pyx_PyInt_As_NEPProblemType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPProblemType neg_one = (NEPProblemType) -1, const_zero = (NEPProblemType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(NEPProblemType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(NEPProblemType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (NEPProblemType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPProblemType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(NEPProblemType, digit, digits[0])
                case 2:
                    if (8 * sizeof(NEPProblemType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPProblemType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPProblemType) >= 2 * PyLong_SHIFT) {
                            return (NEPProblemType) (((((NEPProblemType)digits[1]) << PyLong_SHIFT) | (NEPProblemType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPProblemType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPProblemType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPProblemType) >= 3 * PyLong_SHIFT) {
                            return (NEPProblemType) (((((((NEPProblemType)digits[2]) << PyLong_SHIFT) | (NEPProblemType)digits[1]) << PyLong_SHIFT) | (NEPProblemType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPProblemType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPProblemType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPProblemType) >= 4 * PyLong_SHIFT) {
                            return (NEPProblemType) (((((((((NEPProblemType)digits[3]) << PyLong_SHIFT) | (NEPProblemType)digits[2]) << PyLong_SHIFT) | (NEPProblemType)digits[1]) << PyLong_SHIFT) | (NEPProblemType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (NEPProblemType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(NEPProblemType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPProblemType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPProblemType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPProblemType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPProblemType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(NEPProblemType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(NEPProblemType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(NEPProblemType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPProblemType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPProblemType) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPProblemType) (((NEPProblemType)-1)*(((((NEPProblemType)digits[1]) << PyLong_SHIFT) | (NEPProblemType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(NEPProblemType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPProblemType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPProblemType) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPProblemType) ((((((NEPProblemType)digits[1]) << PyLong_SHIFT) | (NEPProblemType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(NEPProblemType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPProblemType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPProblemType) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPProblemType) (((NEPProblemType)-1)*(((((((NEPProblemType)digits[2]) << PyLong_SHIFT) | (NEPProblemType)digits[1]) << PyLong_SHIFT) | (NEPProblemType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPProblemType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPProblemType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPProblemType) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPProblemType) ((((((((NEPProblemType)digits[2]) << PyLong_SHIFT) | (NEPProblemType)digits[1]) << PyLong_SHIFT) | (NEPProblemType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(NEPProblemType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPProblemType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPProblemType) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPProblemType) (((NEPProblemType)-1)*(((((((((NEPProblemType)digits[3]) << PyLong_SHIFT) | (NEPProblemType)digits[2]) << PyLong_SHIFT) | (NEPProblemType)digits[1]) << PyLong_SHIFT) | (NEPProblemType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPProblemType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPProblemType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPProblemType) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPProblemType) ((((((((((NEPProblemType)digits[3]) << PyLong_SHIFT) | (NEPProblemType)digits[2]) << PyLong_SHIFT) | (NEPProblemType)digits[1]) << PyLong_SHIFT) | (NEPProblemType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(NEPProblemType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPProblemType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPProblemType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPProblemType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            NEPProblemType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (NEPProblemType) -1;
        }
    } else {
        NEPProblemType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (NEPProblemType) -1;
        val = __Pyx_PyInt_As_NEPProblemType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to NEPProblemType");
    return (NEPProblemType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to NEPProblemType");
    return (NEPProblemType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE NEPWhich __Pyx_PyInt_As_NEPWhich(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPWhich neg_one = (NEPWhich) -1, const_zero = (NEPWhich) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(NEPWhich) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(NEPWhich, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (NEPWhich) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPWhich) 0;
                case  1: __PYX_VERIFY_RETURN_INT(NEPWhich, digit, digits[0])
                case 2:
                    if (8 * sizeof(NEPWhich) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPWhich, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPWhich) >= 2 * PyLong_SHIFT) {
                            return (NEPWhich) (((((NEPWhich)digits[1]) << PyLong_SHIFT) | (NEPWhich)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPWhich) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPWhich, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPWhich) >= 3 * PyLong_SHIFT) {
                            return (NEPWhich) (((((((NEPWhich)digits[2]) << PyLong_SHIFT) | (NEPWhich)digits[1]) << PyLong_SHIFT) | (NEPWhich)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPWhich) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPWhich, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPWhich) >= 4 * PyLong_SHIFT) {
                            return (NEPWhich) (((((((((NEPWhich)digits[3]) << PyLong_SHIFT) | (NEPWhich)digits[2]) << PyLong_SHIFT) | (NEPWhich)digits[1]) << PyLong_SHIFT) | (NEPWhich)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (NEPWhich) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(NEPWhich) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPWhich, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPWhich) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPWhich, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPWhich) 0;
                case -1: __PYX_VERIFY_RETURN_INT(NEPWhich, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(NEPWhich,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(NEPWhich) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPWhich, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPWhich) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPWhich) (((NEPWhich)-1)*(((((NEPWhich)digits[1]) << PyLong_SHIFT) | (NEPWhich)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(NEPWhich) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPWhich, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPWhich) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPWhich) ((((((NEPWhich)digits[1]) << PyLong_SHIFT) | (NEPWhich)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(NEPWhich) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPWhich, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPWhich) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPWhich) (((NEPWhich)-1)*(((((((NEPWhich)digits[2]) << PyLong_SHIFT) | (NEPWhich)digits[1]) << PyLong_SHIFT) | (NEPWhich)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPWhich) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPWhich, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPWhich) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPWhich) ((((((((NEPWhich)digits[2]) << PyLong_SHIFT) | (NEPWhich)digits[1]) << PyLong_SHIFT) | (NEPWhich)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(NEPWhich) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPWhich, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPWhich) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPWhich) (((NEPWhich)-1)*(((((((((NEPWhich)digits[3]) << PyLong_SHIFT) | (NEPWhich)digits[2]) << PyLong_SHIFT) | (NEPWhich)digits[1]) << PyLong_SHIFT) | (NEPWhich)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPWhich) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPWhich, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPWhich) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPWhich) ((((((((((NEPWhich)digits[3]) << PyLong_SHIFT) | (NEPWhich)digits[2]) << PyLong_SHIFT) | (NEPWhich)digits[1]) << PyLong_SHIFT) | (NEPWhich)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(NEPWhich) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPWhich, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPWhich) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPWhich, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            NEPWhich val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (NEPWhich) -1;
        }
    } else {
        NEPWhich val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (NEPWhich) -1;
        val = __Pyx_PyInt_As_NEPWhich(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to NEPWhich");
    return (NEPWhich) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to NEPWhich");
    return (NEPWhich) -1;
}

/* CIntFromPy */
static CYTHON_INLINE NEPConv __Pyx_PyInt_As_NEPConv(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPConv neg_one = (NEPConv) -1, const_zero = (NEPConv) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(NEPConv) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(NEPConv, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (NEPConv) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPConv) 0;
                case  1: __PYX_VERIFY_RETURN_INT(NEPConv, digit, digits[0])
                case 2:
                    if (8 * sizeof(NEPConv) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConv, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConv) >= 2 * PyLong_SHIFT) {
                            return (NEPConv) (((((NEPConv)digits[1]) << PyLong_SHIFT) | (NEPConv)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPConv) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConv, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConv) >= 3 * PyLong_SHIFT) {
                            return (NEPConv) (((((((NEPConv)digits[2]) << PyLong_SHIFT) | (NEPConv)digits[1]) << PyLong_SHIFT) | (NEPConv)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPConv) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConv, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConv) >= 4 * PyLong_SHIFT) {
                            return (NEPConv) (((((((((NEPConv)digits[3]) << PyLong_SHIFT) | (NEPConv)digits[2]) << PyLong_SHIFT) | (NEPConv)digits[1]) << PyLong_SHIFT) | (NEPConv)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (NEPConv) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(NEPConv) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPConv, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPConv) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPConv, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPConv) 0;
                case -1: __PYX_VERIFY_RETURN_INT(NEPConv, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(NEPConv,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(NEPConv) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConv, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConv) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPConv) (((NEPConv)-1)*(((((NEPConv)digits[1]) << PyLong_SHIFT) | (NEPConv)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(NEPConv) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConv, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConv) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPConv) ((((((NEPConv)digits[1]) << PyLong_SHIFT) | (NEPConv)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(NEPConv) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConv, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConv) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPConv) (((NEPConv)-1)*(((((((NEPConv)digits[2]) << PyLong_SHIFT) | (NEPConv)digits[1]) << PyLong_SHIFT) | (NEPConv)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPConv) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConv, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConv) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPConv) ((((((((NEPConv)digits[2]) << PyLong_SHIFT) | (NEPConv)digits[1]) << PyLong_SHIFT) | (NEPConv)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(NEPConv) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConv, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConv) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPConv) (((NEPConv)-1)*(((((((((NEPConv)digits[3]) << PyLong_SHIFT) | (NEPConv)digits[2]) << PyLong_SHIFT) | (NEPConv)digits[1]) << PyLong_SHIFT) | (NEPConv)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPConv) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPConv, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPConv) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPConv) ((((((((((NEPConv)digits[3]) << PyLong_SHIFT) | (NEPConv)digits[2]) << PyLong_SHIFT) | (NEPConv)digits[1]) << PyLong_SHIFT) | (NEPConv)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(NEPConv) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPConv, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPConv) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPConv, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            NEPConv val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (NEPConv) -1;
        }
    } else {
        NEPConv val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (NEPConv) -1;
        val = __Pyx_PyInt_As_NEPConv(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to NEPConv");
    return (NEPConv) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to NEPConv");
    return (NEPConv) -1;
}

/* CIntFromPy */
static CYTHON_INLINE NEPRefine __Pyx_PyInt_As_NEPRefine(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPRefine neg_one = (NEPRefine) -1, const_zero = (NEPRefine) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(NEPRefine) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(NEPRefine, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (NEPRefine) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPRefine) 0;
                case  1: __PYX_VERIFY_RETURN_INT(NEPRefine, digit, digits[0])
                case 2:
                    if (8 * sizeof(NEPRefine) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefine, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefine) >= 2 * PyLong_SHIFT) {
                            return (NEPRefine) (((((NEPRefine)digits[1]) << PyLong_SHIFT) | (NEPRefine)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPRefine) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefine, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefine) >= 3 * PyLong_SHIFT) {
                            return (NEPRefine) (((((((NEPRefine)digits[2]) << PyLong_SHIFT) | (NEPRefine)digits[1]) << PyLong_SHIFT) | (NEPRefine)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPRefine) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefine, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefine) >= 4 * PyLong_SHIFT) {
                            return (NEPRefine) (((((((((NEPRefine)digits[3]) << PyLong_SHIFT) | (NEPRefine)digits[2]) << PyLong_SHIFT) | (NEPRefine)digits[1]) << PyLong_SHIFT) | (NEPRefine)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (NEPRefine) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(NEPRefine) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPRefine, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPRefine) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPRefine, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPRefine) 0;
                case -1: __PYX_VERIFY_RETURN_INT(NEPRefine, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(NEPRefine,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(NEPRefine) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefine, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefine) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPRefine) (((NEPRefine)-1)*(((((NEPRefine)digits[1]) << PyLong_SHIFT) | (NEPRefine)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(NEPRefine) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefine, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefine) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPRefine) ((((((NEPRefine)digits[1]) << PyLong_SHIFT) | (NEPRefine)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(NEPRefine) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefine, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefine) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPRefine) (((NEPRefine)-1)*(((((((NEPRefine)digits[2]) << PyLong_SHIFT) | (NEPRefine)digits[1]) << PyLong_SHIFT) | (NEPRefine)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPRefine) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefine, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefine) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPRefine) ((((((((NEPRefine)digits[2]) << PyLong_SHIFT) | (NEPRefine)digits[1]) << PyLong_SHIFT) | (NEPRefine)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(NEPRefine) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefine, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefine) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPRefine) (((NEPRefine)-1)*(((((((((NEPRefine)digits[3]) << PyLong_SHIFT) | (NEPRefine)digits[2]) << PyLong_SHIFT) | (NEPRefine)digits[1]) << PyLong_SHIFT) | (NEPRefine)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPRefine) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefine, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefine) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPRefine) ((((((((((NEPRefine)digits[3]) << PyLong_SHIFT) | (NEPRefine)digits[2]) << PyLong_SHIFT) | (NEPRefine)digits[1]) << PyLong_SHIFT) | (NEPRefine)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(NEPRefine) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPRefine, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPRefine) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPRefine, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            NEPRefine val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (NEPRefine) -1;
        }
    } else {
        NEPRefine val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (NEPRefine) -1;
        val = __Pyx_PyInt_As_NEPRefine(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to NEPRefine");
    return (NEPRefine) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to NEPRefine");
    return (NEPRefine) -1;
}

/* CIntFromPy */
static CYTHON_INLINE NEPRefineScheme __Pyx_PyInt_As_NEPRefineScheme(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPRefineScheme neg_one = (NEPRefineScheme) -1, const_zero = (NEPRefineScheme) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(NEPRefineScheme) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(NEPRefineScheme, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (NEPRefineScheme) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPRefineScheme) 0;
                case  1: __PYX_VERIFY_RETURN_INT(NEPRefineScheme, digit, digits[0])
                case 2:
                    if (8 * sizeof(NEPRefineScheme) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefineScheme, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefineScheme) >= 2 * PyLong_SHIFT) {
                            return (NEPRefineScheme) (((((NEPRefineScheme)digits[1]) << PyLong_SHIFT) | (NEPRefineScheme)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPRefineScheme) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefineScheme, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefineScheme) >= 3 * PyLong_SHIFT) {
                            return (NEPRefineScheme) (((((((NEPRefineScheme)digits[2]) << PyLong_SHIFT) | (NEPRefineScheme)digits[1]) << PyLong_SHIFT) | (NEPRefineScheme)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPRefineScheme) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefineScheme, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefineScheme) >= 4 * PyLong_SHIFT) {
                            return (NEPRefineScheme) (((((((((NEPRefineScheme)digits[3]) << PyLong_SHIFT) | (NEPRefineScheme)digits[2]) << PyLong_SHIFT) | (NEPRefineScheme)digits[1]) << PyLong_SHIFT) | (NEPRefineScheme)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (NEPRefineScheme) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(NEPRefineScheme) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPRefineScheme, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPRefineScheme) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPRefineScheme, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPRefineScheme) 0;
                case -1: __PYX_VERIFY_RETURN_INT(NEPRefineScheme, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(NEPRefineScheme,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(NEPRefineScheme) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefineScheme, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefineScheme) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPRefineScheme) (((NEPRefineScheme)-1)*(((((NEPRefineScheme)digits[1]) << PyLong_SHIFT) | (NEPRefineScheme)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(NEPRefineScheme) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefineScheme, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefineScheme) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPRefineScheme) ((((((NEPRefineScheme)digits[1]) << PyLong_SHIFT) | (NEPRefineScheme)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(NEPRefineScheme) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefineScheme, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefineScheme) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPRefineScheme) (((NEPRefineScheme)-1)*(((((((NEPRefineScheme)digits[2]) << PyLong_SHIFT) | (NEPRefineScheme)digits[1]) << PyLong_SHIFT) | (NEPRefineScheme)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPRefineScheme) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefineScheme, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefineScheme) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPRefineScheme) ((((((((NEPRefineScheme)digits[2]) << PyLong_SHIFT) | (NEPRefineScheme)digits[1]) << PyLong_SHIFT) | (NEPRefineScheme)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(NEPRefineScheme) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefineScheme, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefineScheme) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPRefineScheme) (((NEPRefineScheme)-1)*(((((((((NEPRefineScheme)digits[3]) << PyLong_SHIFT) | (NEPRefineScheme)digits[2]) << PyLong_SHIFT) | (NEPRefineScheme)digits[1]) << PyLong_SHIFT) | (NEPRefineScheme)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPRefineScheme) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPRefineScheme, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPRefineScheme) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPRefineScheme) ((((((((((NEPRefineScheme)digits[3]) << PyLong_SHIFT) | (NEPRefineScheme)digits[2]) << PyLong_SHIFT) | (NEPRefineScheme)digits[1]) << PyLong_SHIFT) | (NEPRefineScheme)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(NEPRefineScheme) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPRefineScheme, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPRefineScheme) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPRefineScheme, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            NEPRefineScheme val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (NEPRefineScheme) -1;
        }
    } else {
        NEPRefineScheme val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (NEPRefineScheme) -1;
        val = __Pyx_PyInt_As_NEPRefineScheme(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to NEPRefineScheme");
    return (NEPRefineScheme) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to NEPRefineScheme");
    return (NEPRefineScheme) -1;
}

/* CIntFromPy */
static CYTHON_INLINE NEPErrorType __Pyx_PyInt_As_NEPErrorType(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPErrorType neg_one = (NEPErrorType) -1, const_zero = (NEPErrorType) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(NEPErrorType) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(NEPErrorType, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (NEPErrorType) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPErrorType) 0;
                case  1: __PYX_VERIFY_RETURN_INT(NEPErrorType, digit, digits[0])
                case 2:
                    if (8 * sizeof(NEPErrorType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPErrorType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPErrorType) >= 2 * PyLong_SHIFT) {
                            return (NEPErrorType) (((((NEPErrorType)digits[1]) << PyLong_SHIFT) | (NEPErrorType)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPErrorType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPErrorType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPErrorType) >= 3 * PyLong_SHIFT) {
                            return (NEPErrorType) (((((((NEPErrorType)digits[2]) << PyLong_SHIFT) | (NEPErrorType)digits[1]) << PyLong_SHIFT) | (NEPErrorType)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPErrorType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPErrorType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPErrorType) >= 4 * PyLong_SHIFT) {
                            return (NEPErrorType) (((((((((NEPErrorType)digits[3]) << PyLong_SHIFT) | (NEPErrorType)digits[2]) << PyLong_SHIFT) | (NEPErrorType)digits[1]) << PyLong_SHIFT) | (NEPErrorType)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (NEPErrorType) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(NEPErrorType) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPErrorType, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPErrorType) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPErrorType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPErrorType) 0;
                case -1: __PYX_VERIFY_RETURN_INT(NEPErrorType, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(NEPErrorType,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(NEPErrorType) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPErrorType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPErrorType) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPErrorType) (((NEPErrorType)-1)*(((((NEPErrorType)digits[1]) << PyLong_SHIFT) | (NEPErrorType)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(NEPErrorType) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPErrorType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPErrorType) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPErrorType) ((((((NEPErrorType)digits[1]) << PyLong_SHIFT) | (NEPErrorType)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(NEPErrorType) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPErrorType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPErrorType) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPErrorType) (((NEPErrorType)-1)*(((((((NEPErrorType)digits[2]) << PyLong_SHIFT) | (NEPErrorType)digits[1]) << PyLong_SHIFT) | (NEPErrorType)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPErrorType) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPErrorType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPErrorType) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPErrorType) ((((((((NEPErrorType)digits[2]) << PyLong_SHIFT) | (NEPErrorType)digits[1]) << PyLong_SHIFT) | (NEPErrorType)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(NEPErrorType) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPErrorType, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPErrorType) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPErrorType) (((NEPErrorType)-1)*(((((((((NEPErrorType)digits[3]) << PyLong_SHIFT) | (NEPErrorType)digits[2]) << PyLong_SHIFT) | (NEPErrorType)digits[1]) << PyLong_SHIFT) | (NEPErrorType)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPErrorType) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPErrorType, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPErrorType) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPErrorType) ((((((((((NEPErrorType)digits[3]) << PyLong_SHIFT) | (NEPErrorType)digits[2]) << PyLong_SHIFT) | (NEPErrorType)digits[1]) << PyLong_SHIFT) | (NEPErrorType)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(NEPErrorType) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPErrorType, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPErrorType) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPErrorType, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            NEPErrorType val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (NEPErrorType) -1;
        }
    } else {
        NEPErrorType val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (NEPErrorType) -1;
        val = __Pyx_PyInt_As_NEPErrorType(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to NEPErrorType");
    return (NEPErrorType) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to NEPErrorType");
    return (NEPErrorType) -1;
}

/* CIntFromPy */
static CYTHON_INLINE NEPCISSExtraction __Pyx_PyInt_As_NEPCISSExtraction(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const NEPCISSExtraction neg_one = (NEPCISSExtraction) -1, const_zero = (NEPCISSExtraction) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(NEPCISSExtraction) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(NEPCISSExtraction, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (NEPCISSExtraction) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPCISSExtraction) 0;
                case  1: __PYX_VERIFY_RETURN_INT(NEPCISSExtraction, digit, digits[0])
                case 2:
                    if (8 * sizeof(NEPCISSExtraction) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPCISSExtraction, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPCISSExtraction) >= 2 * PyLong_SHIFT) {
                            return (NEPCISSExtraction) (((((NEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPCISSExtraction) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPCISSExtraction, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPCISSExtraction) >= 3 * PyLong_SHIFT) {
                            return (NEPCISSExtraction) (((((((NEPCISSExtraction)digits[2]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPCISSExtraction) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPCISSExtraction, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPCISSExtraction) >= 4 * PyLong_SHIFT) {
                            return (NEPCISSExtraction) (((((((((NEPCISSExtraction)digits[3]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[2]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (NEPCISSExtraction) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(NEPCISSExtraction) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPCISSExtraction, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPCISSExtraction) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPCISSExtraction, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (NEPCISSExtraction) 0;
                case -1: __PYX_VERIFY_RETURN_INT(NEPCISSExtraction, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(NEPCISSExtraction,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(NEPCISSExtraction) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPCISSExtraction, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPCISSExtraction) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPCISSExtraction) (((NEPCISSExtraction)-1)*(((((NEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(NEPCISSExtraction) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPCISSExtraction, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPCISSExtraction) - 1 > 2 * PyLong_SHIFT) {
                            return (NEPCISSExtraction) ((((((NEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(NEPCISSExtraction) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPCISSExtraction, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPCISSExtraction) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPCISSExtraction) (((NEPCISSExtraction)-1)*(((((((NEPCISSExtraction)digits[2]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(NEPCISSExtraction) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPCISSExtraction, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPCISSExtraction) - 1 > 3 * PyLong_SHIFT) {
                            return (NEPCISSExtraction) ((((((((NEPCISSExtraction)digits[2]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(NEPCISSExtraction) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPCISSExtraction, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPCISSExtraction) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPCISSExtraction) (((NEPCISSExtraction)-1)*(((((((((NEPCISSExtraction)digits[3]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[2]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(NEPCISSExtraction) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(NEPCISSExtraction, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(NEPCISSExtraction) - 1 > 4 * PyLong_SHIFT) {
                            return (NEPCISSExtraction) ((((((((((NEPCISSExtraction)digits[3]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[2]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[1]) << PyLong_SHIFT) | (NEPCISSExtraction)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(NEPCISSExtraction) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPCISSExtraction, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(NEPCISSExtraction) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(NEPCISSExtraction, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            NEPCISSExtraction val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (NEPCISSExtraction) -1;
        }
    } else {
        NEPCISSExtraction val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (NEPCISSExtraction) -1;
        val = __Pyx_PyInt_As_NEPCISSExtraction(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to NEPCISSExtraction");
    return (NEPCISSExtraction) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to NEPCISSExtraction");
    return (NEPCISSExtraction) -1;
}

/* CIntFromPy */
static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#endif
    const long neg_one = (long) -1, const_zero = (long) 0;
#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
#pragma GCC diagnostic pop
#endif
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(long) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (long) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (long) 0;
                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
                case 2:
                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
                            return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
                            return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
                            return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (long) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(long) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
#endif
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (long) 0;
                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                            return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                            return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                            return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                            return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                            return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                            return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(long) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
#ifdef HAVE_LONG_LONG
            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
#endif
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            long val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (long) -1;
        }
    } else {
        long val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (long) -1;
        val = __Pyx_PyInt_As_long(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to long");
    return (long) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to long");
    return (long) -1;
}

/* FastTypeChecks */
#if CYTHON_COMPILING_IN_CPYTHON
static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
    while (a) {
        a = a->tp_base;
        if (a == b)
            return 1;
    }
    return b == &PyBaseObject_Type;
}
static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
    PyObject *mro;
    if (a == b) return 1;
    mro = a->tp_mro;
    if (likely(mro)) {
        Py_ssize_t i, n;
        n = PyTuple_GET_SIZE(mro);
        for (i = 0; i < n; i++) {
            if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
                return 1;
        }
        return 0;
    }
    return __Pyx_InBases(a, b);
}
#if PY_MAJOR_VERSION == 2
static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
    PyObject *exception, *value, *tb;
    int res;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&exception, &value, &tb);
    res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0;
    if (unlikely(res == -1)) {
        PyErr_WriteUnraisable(err);
        res = 0;
    }
    if (!res) {
        res = PyObject_IsSubclass(err, exc_type2);
        if (unlikely(res == -1)) {
            PyErr_WriteUnraisable(err);
            res = 0;
        }
    }
    __Pyx_ErrRestore(exception, value, tb);
    return res;
}
#else
static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
    if (!res) {
        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
    }
    return res;
}
#endif
static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
    Py_ssize_t i, n;
    assert(PyExceptionClass_Check(exc_type));
    n = PyTuple_GET_SIZE(tuple);
#if PY_MAJOR_VERSION >= 3
    for (i=0; i<n; i++) {
        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
    }
#endif
    for (i=0; i<n; i++) {
        PyObject *t = PyTuple_GET_ITEM(tuple, i);
        #if PY_MAJOR_VERSION < 3
        if (likely(exc_type == t)) return 1;
        #endif
        if (likely(PyExceptionClass_Check(t))) {
            if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1;
        } else {
        }
    }
    return 0;
}
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) {
    if (likely(err == exc_type)) return 1;
    if (likely(PyExceptionClass_Check(err))) {
        if (likely(PyExceptionClass_Check(exc_type))) {
            return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type);
        } else if (likely(PyTuple_Check(exc_type))) {
            return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type);
        } else {
        }
    }
    return PyErr_GivenExceptionMatches(err, exc_type);
}
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) {
    assert(PyExceptionClass_Check(exc_type1));
    assert(PyExceptionClass_Check(exc_type2));
    if (likely(err == exc_type1 || err == exc_type2)) return 1;
    if (likely(PyExceptionClass_Check(err))) {
        return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2);
    }
    return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2));
}
#endif

/* CheckBinaryVersion */
static int __Pyx_check_binary_version(void) {
    char ctversion[5];
    int same=1, i, found_dot;
    const char* rt_from_call = Py_GetVersion();
    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
    found_dot = 0;
    for (i = 0; i < 4; i++) {
        if (!ctversion[i]) {
            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
            break;
        }
        if (rt_from_call[i] != ctversion[i]) {
            same = 0;
            break;
        }
    }
    if (!same) {
        char rtversion[5] = {'\0'};
        char message[200];
        for (i=0; i<4; ++i) {
            if (rt_from_call[i] == '.') {
                if (found_dot) break;
                found_dot = 1;
            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
                break;
            }
            rtversion[i] = rt_from_call[i];
        }
        PyOS_snprintf(message, sizeof(message),
                      "compiletime version %s of module '%.100s' "
                      "does not match runtime version %s",
                      ctversion, __Pyx_MODULE_NAME, rtversion);
        return PyErr_WarnEx(NULL, message, 1);
    }
    return 0;
}

/* FunctionExport */
static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) {
    PyObject *d = 0;
    PyObject *cobj = 0;
    union {
        void (*fp)(void);
        void *p;
    } tmp;
    d = PyObject_GetAttrString(__pyx_m, (char *)"__pyx_capi__");
    if (!d) {
        PyErr_Clear();
        d = PyDict_New();
        if (!d)
            goto bad;
        Py_INCREF(d);
        if (PyModule_AddObject(__pyx_m, (char *)"__pyx_capi__", d) < 0)
            goto bad;
    }
    tmp.fp = f;
#if PY_VERSION_HEX >= 0x02070000
    cobj = PyCapsule_New(tmp.p, sig, 0);
#else
    cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
#endif
    if (!cobj)
        goto bad;
    if (PyDict_SetItemString(d, name, cobj) < 0)
        goto bad;
    Py_DECREF(cobj);
    Py_DECREF(d);
    return 0;
bad:
    Py_XDECREF(cobj);
    Py_XDECREF(d);
    return -1;
}

/* FunctionImport */
#ifndef __PYX_HAVE_RT_ImportFunction
#define __PYX_HAVE_RT_ImportFunction
static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
    PyObject *d = 0;
    PyObject *cobj = 0;
    union {
        void (*fp)(void);
        void *p;
    } tmp;
    d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
    if (!d)
        goto bad;
    cobj = PyDict_GetItemString(d, funcname);
    if (!cobj) {
        PyErr_Format(PyExc_ImportError,
            "%.200s does not export expected C function %.200s",
                PyModule_GetName(module), funcname);
        goto bad;
    }
#if PY_VERSION_HEX >= 0x02070000
    if (!PyCapsule_IsValid(cobj, sig)) {
        PyErr_Format(PyExc_TypeError,
            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
             PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
        goto bad;
    }
    tmp.p = PyCapsule_GetPointer(cobj, sig);
#else
    {const char *desc, *s1, *s2;
    desc = (const char *)PyCObject_GetDesc(cobj);
    if (!desc)
        goto bad;
    s1 = desc; s2 = sig;
    while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
    if (*s1 != *s2) {
        PyErr_Format(PyExc_TypeError,
            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
             PyModule_GetName(module), funcname, sig, desc);
        goto bad;
    }
    tmp.p = PyCObject_AsVoidPtr(cobj);}
#endif
    *f = tmp.fp;
    if (!(*f))
        goto bad;
    Py_DECREF(d);
    return 0;
bad:
    Py_XDECREF(d);
    return -1;
}
#endif

/* InitStrings */
static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
    while (t->p) {
        #if PY_MAJOR_VERSION < 3
        if (t->is_unicode) {
            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
        } else if (t->intern) {
            *t->p = PyString_InternFromString(t->s);
        } else {
            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
        }
        #else
        if (t->is_unicode | t->is_str) {
            if (t->intern) {
                *t->p = PyUnicode_InternFromString(t->s);
            } else if (t->encoding) {
                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
            } else {
                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
            }
        } else {
            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
        }
        #endif
        if (!*t->p)
            return -1;
        if (PyObject_Hash(*t->p) == -1)
            return -1;
        ++t;
    }
    return 0;
}

static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
}
static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
    Py_ssize_t ignore;
    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
}
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
#if !CYTHON_PEP393_ENABLED
static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
    char* defenc_c;
    PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
    if (!defenc) return NULL;
    defenc_c = PyBytes_AS_STRING(defenc);
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
    {
        char* end = defenc_c + PyBytes_GET_SIZE(defenc);
        char* c;
        for (c = defenc_c; c < end; c++) {
            if ((unsigned char) (*c) >= 128) {
                PyUnicode_AsASCIIString(o);
                return NULL;
            }
        }
    }
#endif
    *length = PyBytes_GET_SIZE(defenc);
    return defenc_c;
}
#else
static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
    if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL;
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
    if (likely(PyUnicode_IS_ASCII(o))) {
        *length = PyUnicode_GET_LENGTH(o);
        return PyUnicode_AsUTF8(o);
    } else {
        PyUnicode_AsASCIIString(o);
        return NULL;
    }
#else
    return PyUnicode_AsUTF8AndSize(o, length);
#endif
}
#endif
#endif
static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
    if (
#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
            __Pyx_sys_getdefaultencoding_not_ascii &&
#endif
            PyUnicode_Check(o)) {
        return __Pyx_PyUnicode_AsStringAndSize(o, length);
    } else
#endif
#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
    if (PyByteArray_Check(o)) {
        *length = PyByteArray_GET_SIZE(o);
        return PyByteArray_AS_STRING(o);
    } else
#endif
    {
        char* result;
        int r = PyBytes_AsStringAndSize(o, &result, length);
        if (unlikely(r < 0)) {
            return NULL;
        } else {
            return result;
        }
    }
}
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
   int is_true = x == Py_True;
   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
   else return PyObject_IsTrue(x);
}
static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
    int retval;
    if (unlikely(!x)) return -1;
    retval = __Pyx_PyObject_IsTrue(x);
    Py_DECREF(x);
    return retval;
}
static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
#if PY_MAJOR_VERSION >= 3
    if (PyLong_Check(result)) {
        if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
                "__int__ returned non-int (type %.200s).  "
                "The ability to return an instance of a strict subclass of int "
                "is deprecated, and may be removed in a future version of Python.",
                Py_TYPE(result)->tp_name)) {
            Py_DECREF(result);
            return NULL;
        }
        return result;
    }
#endif
    PyErr_Format(PyExc_TypeError,
                 "__%.4s__ returned non-%.4s (type %.200s)",
                 type_name, type_name, Py_TYPE(result)->tp_name);
    Py_DECREF(result);
    return NULL;
}
static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
#if CYTHON_USE_TYPE_SLOTS
  PyNumberMethods *m;
#endif
  const char *name = NULL;
  PyObject *res = NULL;
#if PY_MAJOR_VERSION < 3
  if (likely(PyInt_Check(x) || PyLong_Check(x)))
#else
  if (likely(PyLong_Check(x)))
#endif
    return __Pyx_NewRef(x);
#if CYTHON_USE_TYPE_SLOTS
  m = Py_TYPE(x)->tp_as_number;
  #if PY_MAJOR_VERSION < 3
  if (m && m->nb_int) {
    name = "int";
    res = m->nb_int(x);
  }
  else if (m && m->nb_long) {
    name = "long";
    res = m->nb_long(x);
  }
  #else
  if (likely(m && m->nb_int)) {
    name = "int";
    res = m->nb_int(x);
  }
  #endif
#else
  if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) {
    res = PyNumber_Int(x);
  }
#endif
  if (likely(res)) {
#if PY_MAJOR_VERSION < 3
    if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) {
#else
    if (unlikely(!PyLong_CheckExact(res))) {
#endif
        return __Pyx_PyNumber_IntOrLongWrongResultType(res, name);
    }
  }
  else if (!PyErr_Occurred()) {
    PyErr_SetString(PyExc_TypeError,
                    "an integer is required");
  }
  return res;
}
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
  Py_ssize_t ival;
  PyObject *x;
#if PY_MAJOR_VERSION < 3
  if (likely(PyInt_CheckExact(b))) {
    if (sizeof(Py_ssize_t) >= sizeof(long))
        return PyInt_AS_LONG(b);
    else
        return PyInt_AsSsize_t(b);
  }
#endif
  if (likely(PyLong_CheckExact(b))) {
    #if CYTHON_USE_PYLONG_INTERNALS
    const digit* digits = ((PyLongObject*)b)->ob_digit;
    const Py_ssize_t size = Py_SIZE(b);
    if (likely(__Pyx_sst_abs(size) <= 1)) {
        ival = likely(size) ? digits[0] : 0;
        if (size == -1) ival = -ival;
        return ival;
    } else {
      switch (size) {
         case 2:
           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -2:
           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case 3:
           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -3:
           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case 4:
           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -4:
           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
      }
    }
    #endif
    return PyLong_AsSsize_t(b);
  }
  x = PyNumber_Index(b);
  if (!x) return -1;
  ival = PyInt_AsSsize_t(x);
  Py_DECREF(x);
  return ival;
}
static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) {
  if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) {
    return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o);
#if PY_MAJOR_VERSION < 3
  } else if (likely(PyInt_CheckExact(o))) {
    return PyInt_AS_LONG(o);
#endif
  } else {
    Py_ssize_t ival;
    PyObject *x;
    x = PyNumber_Index(o);
    if (!x) return -1;
    ival = PyInt_AsLong(x);
    Py_DECREF(x);
    return ival;
  }
}
static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {
  return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False);
}
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
    return PyInt_FromSize_t(ival);
}


#endif /* Py_PYTHON_H */
