From fbf5cd7c1c5ad17591b303e7cac24c224518c733 Mon Sep 17 00:00:00 2001 From: ltcptgeneral <35508619+ltcptgeneral@users.noreply.github.com> Date: Wed, 25 Sep 2019 14:14:17 -0500 Subject: [PATCH] quick fix --- data analysis/analysis/dep/analysis.c | 35536 ++++++++++++++++ .../analysis/dep/analysis.cp37-win_amd64.pyd | Bin 0 -> 366592 bytes 2 files changed, 35536 insertions(+) create mode 100644 data analysis/analysis/dep/analysis.c create mode 100644 data analysis/analysis/dep/analysis.cp37-win_amd64.pyd diff --git a/data analysis/analysis/dep/analysis.c b/data analysis/analysis/dep/analysis.c new file mode 100644 index 00000000..ffd6715f --- /dev/null +++ b/data analysis/analysis/dep/analysis.c @@ -0,0 +1,35536 @@ +/* Generated by Cython 0.29.6 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "name": "analysis", + "sources": [ + "analysis.py" + ] + }, + "module_name": "analysis" +} +END: Cython Metadata */ + +#define 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_6" +#define CYTHON_HEX_VERSION 0x001D06F0 +#define CYTHON_FUTURE_DIVISION 0 +#include +#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 + #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 +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 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 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #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 + #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 + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #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 + #ifndef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #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 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 +#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_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 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 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #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) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) +#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 + #define PyObject_Unicode PyObject_Str +#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 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 PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : (Py_INCREF(func), 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(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#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_ERR(f_index, lineno, Ln_error) \ +{ \ + __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; 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__analysis +#define __PYX_HAVE_API__analysis +/* Early includes */ +#ifdef _OPENMP +#include +#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 + #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); +#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[] = { + "analysis.py", +}; + +/*--- Type declarations ---*/ +struct __pyx_obj_8analysis___pyx_scope_struct___sum; +struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr; +struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg; +struct __pyx_obj_8analysis___pyx_scope_struct_3__ss; +struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr; +struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr; + +/* "analysis.py":962 + * + * + * def _sum(data, start=0): # <<<<<<<<<<<<<< + * count = 0 + * n, d = _exact_ratio(start) + */ +struct __pyx_obj_8analysis___pyx_scope_struct___sum { + PyObject_HEAD + PyObject *__pyx_v_partials; +}; + + +/* "analysis.py":979 + * else: + * + * total = sum(Fraction(n, d) for d, n in sorted(partials.items())) # <<<<<<<<<<<<<< + * return (T, total, count) + * + */ +struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr { + PyObject_HEAD + struct __pyx_obj_8analysis___pyx_scope_struct___sum *__pyx_outer_scope; + PyObject *__pyx_v_d; + PyObject *__pyx_v_n; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; +}; + + +/* "analysis.py":1092 + * + * + * def _fail_neg(values, errmsg='negative value'): # <<<<<<<<<<<<<< + * + * for x in values: + */ +struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg { + PyObject_HEAD + PyObject *__pyx_v_errmsg; + PyObject *__pyx_v_values; + PyObject *__pyx_v_x; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; + PyObject *(*__pyx_t_2)(PyObject *); +}; + + +/* "analysis.py":1138 + * + * + * def _ss(data, c=None): # <<<<<<<<<<<<<< + * + * if c is None: + */ +struct __pyx_obj_8analysis___pyx_scope_struct_3__ss { + PyObject_HEAD + PyObject *__pyx_v_c; + PyObject *__pyx_v_data; +}; + + +/* "analysis.py":1142 + * if c is None: + * c = mean(data) + * T, total, count = _sum((x - c)**2 for x in data) # <<<<<<<<<<<<<< + * + * U, total2, count2 = _sum((x - c) for x in data) + */ +struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr { + PyObject_HEAD + struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *__pyx_outer_scope; + PyObject *__pyx_v_x; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; + PyObject *(*__pyx_t_2)(PyObject *); +}; + + +/* "analysis.py":1144 + * T, total, count = _sum((x - c)**2 for x in data) + * + * U, total2, count2 = _sum((x - c) for x in data) # <<<<<<<<<<<<<< + * assert T == U and count == count2 + * total -= total2**2 / len(data) + */ +struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr { + PyObject_HEAD + struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *__pyx_outer_scope; + PyObject *__pyx_v_x; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; + PyObject *(*__pyx_t_2)(PyObject *); +}; + + +/* --- 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); + +/* 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); + +/* 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); + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* StrEquals.proto */ +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals +#else +#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals +#endif + +/* 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 + +/* 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, int 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 + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" + #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 + +/* 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); + +/* PyObjectCall2Args.proto */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* 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 + +/* 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 + +/* 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 + +/* 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 + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* 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 + +/* 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); + Py_SIZE(list) = len+1; + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* 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); + +/* SetItemInt.proto */ +#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ + __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, + int is_list, int wraparound, int boundscheck); + +/* PyObjectLookupSpecial.proto */ +#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name) { + PyObject *res; + PyTypeObject *tp = Py_TYPE(obj); +#if PY_MAJOR_VERSION < 3 + if (unlikely(PyInstance_Check(obj))) + return __Pyx_PyObject_GetAttrStr(obj, attr_name); +#endif + res = _PyType_Lookup(tp, attr_name); + if (likely(res)) { + descrgetfunc f = Py_TYPE(res)->tp_descr_get; + if (!f) { + Py_INCREF(res); + } else { + res = f(res, obj, (PyObject *)tp); + } + } else { + PyErr_SetObject(PyExc_AttributeError, attr_name); + } + return res; +} +#else +#define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n) +#endif + +/* None.proto */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* PyIntCompare.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, long inplace); + +/* ObjectGetItem.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); +#else +#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) +#endif + +/* 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); + +/* pyobject_as_double.proto */ +static double __Pyx__PyObject_AsDouble(PyObject* obj); +#if CYTHON_COMPILING_IN_PYPY +#define __Pyx_PyObject_AsDouble(obj)\ +(likely(PyFloat_CheckExact(obj)) ? PyFloat_AS_DOUBLE(obj) :\ + likely(PyInt_CheckExact(obj)) ?\ + PyFloat_AsDouble(obj) : __Pyx__PyObject_AsDouble(obj)) +#else +#define __Pyx_PyObject_AsDouble(obj)\ +((likely(PyFloat_CheckExact(obj))) ?\ + PyFloat_AS_DOUBLE(obj) : __Pyx__PyObject_AsDouble(obj)) +#endif + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_SubtractObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) +#endif + +/* SliceObject.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( + PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** py_start, PyObject** py_stop, PyObject** py_slice, + int has_cstart, int has_cstop, int wraparound); + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +/* FetchCommonType.proto */ +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); + +/* CythonFunction.proto */ +#define __Pyx_CyFunction_USED 1 +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { + PyCFunctionObject func; +#if PY_VERSION_HEX < 0x030500A0 + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; + PyObject *func_classobj; + void *defaults; + int defaults_pyobjects; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; +} __pyx_CyFunctionObject; +static PyTypeObject *__pyx_CyFunctionType = 0; +#define __Pyx_CyFunction_Check(obj) (__Pyx_TypeCheck(obj, __pyx_CyFunctionType)) +#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\ + __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code) +static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *self, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(void); + +/* pop_index.proto */ +static PyObject* __Pyx__PyObject_PopNewIndex(PyObject* L, PyObject* py_ix); +static PyObject* __Pyx__PyObject_PopIndex(PyObject* L, PyObject* py_ix); +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static PyObject* __Pyx__PyList_PopIndex(PyObject* L, PyObject* py_ix, Py_ssize_t ix); +#define __Pyx_PyObject_PopIndex(L, py_ix, ix, is_signed, type, to_py_func) (\ + (likely(PyList_CheckExact(L) && __Pyx_fits_Py_ssize_t(ix, type, is_signed))) ?\ + __Pyx__PyList_PopIndex(L, py_ix, ix) : (\ + (unlikely((py_ix) == Py_None)) ? __Pyx__PyObject_PopNewIndex(L, to_py_func(ix)) :\ + __Pyx__PyObject_PopIndex(L, py_ix))) +#define __Pyx_PyList_PopIndex(L, py_ix, ix, is_signed, type, to_py_func) (\ + __Pyx_fits_Py_ssize_t(ix, type, is_signed) ?\ + __Pyx__PyList_PopIndex(L, py_ix, ix) : (\ + (unlikely((py_ix) == Py_None)) ? __Pyx__PyObject_PopNewIndex(L, to_py_func(ix)) :\ + __Pyx__PyObject_PopIndex(L, py_ix))) +#else +#define __Pyx_PyList_PopIndex(L, py_ix, ix, is_signed, type, to_py_func)\ + __Pyx_PyObject_PopIndex(L, py_ix, ix, is_signed, type, to_py_func) +#define __Pyx_PyObject_PopIndex(L, py_ix, ix, is_signed, type, to_py_func) (\ + (unlikely((py_ix) == Py_None)) ? __Pyx__PyObject_PopNewIndex(L, to_py_func(ix)) :\ + __Pyx__PyObject_PopIndex(L, py_ix)) +#endif + +/* UnpackUnboundCMethod.proto */ +typedef struct { + PyObject *type; + PyObject **method_name; + PyCFunction func; + PyObject *method; + int flag; +} __Pyx_CachedCFunction; + +/* CallUnboundCMethod1.proto */ +static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); +#else +#define __Pyx_CallUnboundCMethod1(cfunc, self, arg) __Pyx__CallUnboundCMethod1(cfunc, self, arg) +#endif + +/* py_dict_items.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d); + +/* CallUnboundCMethod0.proto */ +static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CallUnboundCMethod0(cfunc, self)\ + (likely((cfunc)->func) ?\ + (likely((cfunc)->flag == METH_NOARGS) ? (*((cfunc)->func))(self, NULL) :\ + (PY_VERSION_HEX >= 0x030600B1 && likely((cfunc)->flag == METH_FASTCALL) ?\ + (PY_VERSION_HEX >= 0x030700A0 ?\ + (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0) :\ + (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0, NULL)) :\ + (PY_VERSION_HEX >= 0x030700A0 && (cfunc)->flag == (METH_FASTCALL | METH_KEYWORDS) ?\ + (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0, NULL) :\ + (likely((cfunc)->flag == (METH_VARARGS | METH_KEYWORDS)) ? ((*(PyCFunctionWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, __pyx_empty_tuple, NULL)) :\ + ((cfunc)->flag == METH_VARARGS ? (*((cfunc)->func))(self, __pyx_empty_tuple) :\ + __Pyx__CallUnboundCMethod0(cfunc, self)))))) :\ + __Pyx__CallUnboundCMethod0(cfunc, self)) +#else +#define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self) +#endif + +/* None.proto */ +static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname); + +/* dict_getitem_default.proto */ +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); + +/* CallUnboundCMethod2.proto */ +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030600B1 +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); +#else +#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) +#endif + +/* PyDictContains.proto */ +static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) { + int result = PyDict_Contains(dict, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* DictGetItem.proto */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); +#define __Pyx_PyObject_Dict_GetItem(obj, name)\ + (likely(PyDict_CheckExact(obj)) ?\ + __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) +#else +#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) +#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 + +/* PyIntCompare.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_NeObjC(PyObject *op1, PyObject *op2, long intval, long inplace); + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_RemainderObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_RemainderObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceRemainder(op1, op2) : PyNumber_Remainder(op1, op2)) +#endif + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_FloorDivideObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_FloorDivideObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceFloorDivide(op1, op2) : PyNumber_FloorDivide(op1, op2)) +#endif + +/* 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 + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* CalculateMetaclass.proto */ +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); + +/* 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); + +/* 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 + +/* 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); + +/* Print.proto */ +static int __Pyx_Print(PyObject*, PyObject *, int); +#if CYTHON_COMPILING_IN_PYPY || PY_MAJOR_VERSION >= 3 +static PyObject* __pyx_print = 0; +static PyObject* __pyx_print_kwargs = 0; +#endif + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* PyExec.proto */ +static PyObject* __Pyx_PyExec3(PyObject*, PyObject*, PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyExec2(PyObject*, PyObject*); + +/* PrintOne.proto */ +static int __Pyx_PrintOne(PyObject* stream, PyObject *o); + +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + +/* Globals.proto */ +static PyObject* __Pyx_Globals(void); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(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) + +/* 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 + +/* CoroutineBase.proto */ +typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyThreadState *, PyObject *); +#if CYTHON_USE_EXC_INFO_STACK +#define __Pyx_ExcInfoStruct _PyErr_StackItem +#else +typedef struct { + PyObject *exc_type; + PyObject *exc_value; + PyObject *exc_traceback; +} __Pyx_ExcInfoStruct; +#endif +typedef struct { + PyObject_HEAD + __pyx_coroutine_body_t body; + PyObject *closure; + __Pyx_ExcInfoStruct gi_exc_state; + PyObject *gi_weakreflist; + PyObject *classobj; + PyObject *yieldfrom; + PyObject *gi_name; + PyObject *gi_qualname; + PyObject *gi_modulename; + PyObject *gi_code; + int resume_label; + char is_running; +} __pyx_CoroutineObject; +static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject *type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); +static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( + __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); +static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *self); +static int __Pyx_Coroutine_clear(PyObject *self); +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); +static PyObject *__Pyx_Coroutine_Close(PyObject *self); +static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); +#if CYTHON_USE_EXC_INFO_STACK +#define __Pyx_Coroutine_SwapException(self) +#define __Pyx_Coroutine_ResetAndClearException(self) __Pyx_Coroutine_ExceptionClear(&(self)->gi_exc_state) +#else +#define __Pyx_Coroutine_SwapException(self) {\ + __Pyx_ExceptionSwap(&(self)->gi_exc_state.exc_type, &(self)->gi_exc_state.exc_value, &(self)->gi_exc_state.exc_traceback);\ + __Pyx_Coroutine_ResetFrameBackpointer(&(self)->gi_exc_state);\ + } +#define __Pyx_Coroutine_ResetAndClearException(self) {\ + __Pyx_ExceptionReset((self)->gi_exc_state.exc_type, (self)->gi_exc_state.exc_value, (self)->gi_exc_state.exc_traceback);\ + (self)->gi_exc_state.exc_type = (self)->gi_exc_state.exc_value = (self)->gi_exc_state.exc_traceback = NULL;\ + } +#endif +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ + __Pyx_PyGen__FetchStopIterationValue(__pyx_tstate, pvalue) +#else +#define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ + __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, pvalue) +#endif +static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue); +static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state); + +/* PatchModuleWithCoroutine.proto */ +static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code); + +/* PatchGeneratorABC.proto */ +static int __Pyx_patch_abc(void); + +/* Generator.proto */ +#define __Pyx_Generator_USED +static PyTypeObject *__pyx_GeneratorType = 0; +#define __Pyx_Generator_CheckExact(obj) (Py_TYPE(obj) == __pyx_GeneratorType) +#define __Pyx_Generator_New(body, code, closure, name, qualname, module_name)\ + __Pyx__Coroutine_New(__pyx_GeneratorType, body, code, closure, name, qualname, module_name) +static PyObject *__Pyx_Generator_Next(PyObject *self); +static int __pyx_Generator_init(void); + +/* CStringEquals.proto */ +static CYTHON_INLINE int __Pyx_StrEq(const char *, const char *); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + + +/* Module declarations from 'analysis' */ +static PyTypeObject *__pyx_ptype_8analysis___pyx_scope_struct___sum = 0; +static PyTypeObject *__pyx_ptype_8analysis___pyx_scope_struct_1_genexpr = 0; +static PyTypeObject *__pyx_ptype_8analysis___pyx_scope_struct_2__fail_neg = 0; +static PyTypeObject *__pyx_ptype_8analysis___pyx_scope_struct_3__ss = 0; +static PyTypeObject *__pyx_ptype_8analysis___pyx_scope_struct_4_genexpr = 0; +static PyTypeObject *__pyx_ptype_8analysis___pyx_scope_struct_5_genexpr = 0; +#define __Pyx_MODULE_NAME "analysis" +extern int __pyx_module_is_main_analysis; +int __pyx_module_is_main_analysis = 0; + +/* Implementation of 'analysis' */ +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_open; +static PyObject *__pyx_builtin_sorted; +static PyObject *__pyx_builtin_max; +static PyObject *__pyx_builtin_map; +static PyObject *__pyx_builtin_sum; +static PyObject *__pyx_builtin_AttributeError; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_OverflowError; +static const char __pyx_k_[] = ":"; +static const char __pyx_k_S[] = "S"; +static const char __pyx_k_T[] = "T"; +static const char __pyx_k_U[] = "U"; +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_i[] = "i"; +static const char __pyx_k_j[] = "j"; +static const char __pyx_k_l[] = "l"; +static const char __pyx_k_n[] = "n"; +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_1d[] = "1d"; +static const char __pyx_k__2[] = ""; +static const char __pyx_k__5[] = ")+"; +static const char __pyx_k__6[] = ")"; +static const char __pyx_k__7[] = "))+"; +static const char __pyx_k__8[] = "("; +static const char __pyx_k__9[] = "**("; +static const char __pyx_k_lo[] = "lo"; +static const char __pyx_k_np[] = "np"; +static const char __pyx_k_pi[] = "pi"; +static const char __pyx_k_ss[] = "_ss"; +static const char __pyx_k__10[] = "))"; +static const char __pyx_k__13[] = ")) + "; +static const char __pyx_k__14[] = ","; +static const char __pyx_k__15[] = "\n"; +static const char __pyx_k__17[] = "*"; +static const char __pyx_k_all[] = "__all__"; +static const char __pyx_k_arg[] = "arg"; +static const char __pyx_k_cpu[] = "cpu"; +static const char __pyx_k_csv[] = "csv"; +static const char __pyx_k_deg[] = "deg"; +static const char __pyx_k_doc[] = "__doc__"; +static const char __pyx_k_end[] = "end"; +static const char __pyx_k_eqs[] = "eqs"; +static const char __pyx_k_eve[] = "eve"; +static const char __pyx_k_get[] = "get"; +static const char __pyx_k_ids[] = "ids"; +static const char __pyx_k_ind[] = "ind"; +static const char __pyx_k_key[] = "key"; +static const char __pyx_k_log[] = "log"; +static const char __pyx_k_low[] = "low"; +static const char __pyx_k_map[] = "map"; +static const char __pyx_k_max[] = "max"; +static const char __pyx_k_msg[] = "msg"; +static const char __pyx_k_pop[] = "pop"; +static const char __pyx_k_pos[] = "pos"; +static const char __pyx_k_r2s[] = "r2s"; +static const char __pyx_k_rms[] = "_rms"; +static const char __pyx_k_row[] = "row"; +static const char __pyx_k_sum[] = "sum"; +static const char __pyx_k_typ[] = "typ"; +static const char __pyx_k_var[] = "var"; +static const char __pyx_k_z_2[] = "z"; +static const char __pyx_k_z_3[] = "*z))*("; +static const char __pyx_k_z_4[] = "*(z - "; +static const char __pyx_k_adam[] = "adam"; +static const char __pyx_k_args[] = "args"; +static const char __pyx_k_b_eq[] = "b_eq"; +static const char __pyx_k_b_r2[] = "b_r2"; +static const char __pyx_k_base[] = "base"; +static const char __pyx_k_both[] = "both"; +static const char __pyx_k_cuda[] = "cuda"; +static const char __pyx_k_data[] = "data"; +static const char __pyx_k_edit[] = "edit"; +static const char __pyx_k_exit[] = "__exit__"; +static const char __pyx_k_file[] = "file"; +static const char __pyx_k_high[] = "high"; +static const char __pyx_k_init[] = "__init__"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_math[] = "math"; +static const char __pyx_k_mean[] = "mean"; +static const char __pyx_k_mode[] = "mode"; +static const char __pyx_k_n_id[] = "n_id"; +static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_null[] = "null"; +static const char __pyx_k_open[] = "open"; +static const char __pyx_k_rmss[] = "rmss"; +static const char __pyx_k_self[] = "self"; +static const char __pyx_k_send[] = "send"; +static const char __pyx_k_sqrt[] = "sqrt"; +static const char __pyx_k_ss_2[] = "ss"; +static const char __pyx_k_tanh[] = "tanh"; +static const char __pyx_k_temp[] = "temp"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_time[] = "time"; +static const char __pyx_k_vals[] = "vals"; +static const char __pyx_k_xbar[] = "xbar"; +static const char __pyx_k_array[] = "array"; +static const char __pyx_k_b_rms[] = "b_rms"; +static const char __pyx_k_c_ids[] = "c_ids"; +static const char __pyx_k_c_pos[] = "c_pos"; +static const char __pyx_k_close[] = "close"; +static const char __pyx_k_count[] = "count"; +static const char __pyx_k_debug[] = "debug"; +static const char __pyx_k_delta[] = "delta"; +static const char __pyx_k_end_a[] = "end_a"; +static const char __pyx_k_end_g[] = "end_g"; +static const char __pyx_k_enter[] = "__enter__"; +static const char __pyx_k_error[] = "error"; +static const char __pyx_k_floor[] = "floor"; +static const char __pyx_k_index[] = "index"; +static const char __pyx_k_items[] = "items"; +static const char __pyx_k_logic[] = "logic"; +static const char __pyx_k_n_pos[] = "n_pos"; +static const char __pyx_k_names[] = "names"; +static const char __pyx_k_numpy[] = "numpy"; +static const char __pyx_k_point[] = "point"; +static const char __pyx_k_power[] = "power"; +static const char __pyx_k_print[] = "print"; +static const char __pyx_k_q_str[] = "q_str"; +static const char __pyx_k_r2_d2[] = "r2_d2"; +static const char __pyx_k_range[] = "range"; +static const char __pyx_k_rms_2[] = "rms"; +static const char __pyx_k_scipy[] = "scipy"; +static const char __pyx_k_score[] = "score"; +static const char __pyx_k_start[] = "start"; +static const char __pyx_k_stats[] = "stats"; +static const char __pyx_k_stdev[] = "stdev"; +static const char __pyx_k_sum_2[] = "_sum"; +static const char __pyx_k_table[] = "table"; +static const char __pyx_k_throw[] = "throw"; +static const char __pyx_k_torch[] = "torch"; +static const char __pyx_k_total[] = "total"; +static const char __pyx_k_value[] = "value"; +static const char __pyx_k_write[] = "write"; +static const char __pyx_k_x_fit[] = "x_fit"; +static const char __pyx_k_y_fit[] = "y_fit"; +static const char __pyx_k_append[] = "append"; +static const char __pyx_k_argmax[] = "argmax"; +static const char __pyx_k_argmin[] = "argmin"; +static const char __pyx_k_author[] = "__author__"; +static const char __pyx_k_bisect[] = "bisect"; +static const char __pyx_k_c_data[] = "c_data"; +static const char __pyx_k_coerce[] = "_coerce"; +static const char __pyx_k_column[] = "column"; +static const char __pyx_k_count2[] = "count2"; +static const char __pyx_k_counts[] = "_counts"; +static const char __pyx_k_data_t[] = "data_t"; +static const char __pyx_k_device[] = "device"; +static const char __pyx_k_eq_str[] = "eq_str"; +static const char __pyx_k_errmsg[] = "errmsg"; +static const char __pyx_k_format[] = "format"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_mean_2[] = "_mean"; +static const char __pyx_k_median[] = "median"; +static const char __pyx_k_method[] = "method"; +static const char __pyx_k_mode_2[] = "_mode"; +static const char __pyx_k_module[] = "__module__"; +static const char __pyx_k_n_name[] = "n_name"; +static const char __pyx_k_pandas[] = "pandas"; +static const char __pyx_k_perims[] = "perims"; +static const char __pyx_k_r_data[] = "r_data"; +static const char __pyx_k_random[] = "random"; +static const char __pyx_k_reader[] = "reader"; +static const char __pyx_k_reg_eq[] = "reg_eq"; +static const char __pyx_k_remove[] = "remove"; +static const char __pyx_k_search[] = "search"; +static const char __pyx_k_sorted[] = "sorted"; +static const char __pyx_k_tolist[] = "tolist"; +static const char __pyx_k_total2[] = "total2"; +static const char __pyx_k_values[] = "values"; +static const char __pyx_k_x_norm[] = "x_norm"; +static const char __pyx_k_x_test[] = "x_test"; +static const char __pyx_k_y_norm[] = "y_norm"; +static const char __pyx_k_y_test[] = "y_test"; +static const char __pyx_k_Counter[] = "Counter"; +static const char __pyx_k_Decimal[] = "Decimal"; +static const char __pyx_k_c_logic[] = "c_logic"; +static const char __pyx_k_c_names[] = "c_names"; +static const char __pyx_k_c_perim[] = "c_perim"; +static const char __pyx_k_convert[] = "_convert"; +static const char __pyx_k_csvfile[] = "csvfile"; +static const char __pyx_k_decimal[] = "decimal"; +static const char __pyx_k_effects[] = "effects"; +static const char __pyx_k_float64[] = "float64"; +static const char __pyx_k_genexpr[] = "genexpr"; +static const char __pyx_k_groupby[] = "groupby"; +static const char __pyx_k_max_r2s[] = "max_r2s"; +static const char __pyx_k_maxfreq[] = "maxfreq"; +static const char __pyx_k_metrics[] = "metrics"; +static const char __pyx_k_n_logic[] = "n_logic"; +static const char __pyx_k_n_perim[] = "n_perim"; +static const char __pyx_k_newline[] = "newline"; +static const char __pyx_k_np_tanh[] = " * np.tanh("; +static const char __pyx_k_numbers[] = "numbers"; +static const char __pyx_k_overfit[] = "overfit"; +static const char __pyx_k_p_value[] = "p_value"; +static const char __pyx_k_polyfit[] = "polyfit"; +static const char __pyx_k_prepare[] = "__prepare__"; +static const char __pyx_k_r2_test[] = "r2_test"; +static const char __pyx_k_randint[] = "randint"; +static const char __pyx_k_range_2[] = "_range"; +static const char __pyx_k_setting[] = "setting"; +static const char __pyx_k_sklearn[] = "sklearn"; +static const char __pyx_k_start_a[] = "start_a"; +static const char __pyx_k_start_g[] = "start_g"; +static const char __pyx_k_stdev_2[] = "_stdev"; +static const char __pyx_k_targets[] = "targets"; +static const char __pyx_k_uniform[] = "uniform"; +static const char __pyx_k_version[] = "__version__"; +static const char __pyx_k_x_train[] = "x_train"; +static const char __pyx_k_y_train[] = "y_train"; +static const char __pyx_k_z_score[] = "z_score"; +static const char __pyx_k_z_split[] = "z_split"; +static const char __pyx_k_Fraction[] = "Fraction"; +static const char __pyx_k_analysis[] = "analysis"; +static const char __pyx_k_builtins[] = "__builtins__"; +static const char __pyx_k_equation[] = "equation"; +static const char __pyx_k_fail_neg[] = "_fail_neg"; +static const char __pyx_k_filename[] = "filename"; +static const char __pyx_k_filepath[] = "filepath"; +static const char __pyx_k_isfinite[] = "_isfinite"; +static const char __pyx_k_load_csv[] = "load_csv"; +static const char __pyx_k_median_2[] = "_median"; +static const char __pyx_k_n_effect[] = "n_effect"; +static const char __pyx_k_partials[] = "partials"; +static const char __pyx_k_position[] = "position"; +static const char __pyx_k_qualname[] = "__qualname__"; +static const char __pyx_k_r2_score[] = "r2_score"; +static const char __pyx_k_r2_train[] = "r2_train"; +static const char __pyx_k_rms_test[] = "rms_test"; +static const char __pyx_k_selector[] = "selector"; +static const char __pyx_k_variance[] = "variance"; +static const char __pyx_k_1_0_8_005[] = "1.0.8.005"; +static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_b_overfit[] = "b_overfit"; +static const char __pyx_k_benchmark[] = "benchmark"; +static const char __pyx_k_c_effects[] = "c_effects"; +static const char __pyx_k_changelog[] = "__changelog__"; +static const char __pyx_k_curve_fit[] = "curve_fit"; +static const char __pyx_k_find_lteq[] = "_find_lteq"; +static const char __pyx_k_find_rteq[] = "_find_rteq"; +static const char __pyx_k_fractions[] = "fractions"; +static const char __pyx_k_functools[] = "functools"; +static const char __pyx_k_hist_data[] = "hist_data"; +static const char __pyx_k_is_finite[] = "is_finite"; +static const char __pyx_k_itertools[] = "itertools"; +static const char __pyx_k_low_bound[] = "low_bound"; +static const char __pyx_k_metaclass[] = "__metaclass__"; +static const char __pyx_k_numerator[] = "numerator"; +static const char __pyx_k_obstacles[] = "obstacles"; +static const char __pyx_k_r_squared[] = "r_squared"; +static const char __pyx_k_rms_train[] = "rms_train"; +static const char __pyx_k_row_histo[] = "row_histo"; +static const char __pyx_k_ttest_ind[] = "ttest_ind"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_c_entities[] = "c_entities"; +static const char __pyx_k_column_max[] = "column_max"; +static const char __pyx_k_derivative[] = "derivative"; +static const char __pyx_k_file_array[] = "file_array"; +static const char __pyx_k_high_bound[] = "high_bound"; +static const char __pyx_k_isfinite_2[] = "isfinite"; +static const char __pyx_k_matplotlib[] = "matplotlib"; +static const char __pyx_k_mode_error[] = "mode error"; +static const char __pyx_k_n_property[] = "n_property"; +static const char __pyx_k_objectives[] = "objectives"; +static const char __pyx_k_properties[] = "properties"; +static const char __pyx_k_resolution[] = "resolution"; +static const char __pyx_k_strip_data[] = "strip_data"; +static const char __pyx_k_variance_2[] = "_variance"; +static const char __pyx_k_analysis_py[] = "analysis.py"; +static const char __pyx_k_basic_stats[] = "basic_stats"; +static const char __pyx_k_bisect_left[] = "bisect_left"; +static const char __pyx_k_collections[] = "collections"; +static const char __pyx_k_denominator[] = "denominator"; +static const char __pyx_k_exact_ratio[] = "_exact_ratio"; +static const char __pyx_k_init_device[] = "_init_device"; +static const char __pyx_k_min_overfit[] = "min_overfit"; +static const char __pyx_k_most_common[] = "most_common"; +static const char __pyx_k_nc_entities[] = "nc_entities"; +static const char __pyx_k_pred_change[] = "pred_change"; +static const char __pyx_k_predictions[] = "predictions"; +static const char __pyx_k_regurgitate[] = "regurgitate"; +static const char __pyx_k_row_b_stats[] = "row_b_stats"; +static const char __pyx_k_vals_append[] = "vals.append("; +static const char __pyx_k_z_normalize[] = "z_normalize"; +static const char __pyx_k_bisect_right[] = "bisect_right"; +static const char __pyx_k_c_properties[] = "c_properties"; +static const char __pyx_k_calc_overfit[] = "calc_overfit"; +static const char __pyx_k_is_available[] = "is_available"; +static const char __pyx_k_method_error[] = "method error"; +static const char __pyx_k_partials_get[] = "partials_get"; +static const char __pyx_k_OverflowError[] = "OverflowError"; +static const char __pyx_k_c_data_sorted[] = "c_data_sorted"; +static const char __pyx_k_data_data_csv[] = "data/data.csv"; +static const char __pyx_k_generate_data[] = "generate_data"; +static const char __pyx_k_stdev_z_split[] = "stdev_z_split"; +static const char __pyx_k_AttributeError[] = "AttributeError"; +static const char __pyx_k_basic_analysis[] = "basic_analysis"; +static const char __pyx_k_column_b_stats[] = "column_b_stats"; +static const char __pyx_k_exp_regression[] = "exp_regression"; +static const char __pyx_k_histo_analysis[] = "histo_analysis"; +static const char __pyx_k_log_regression[] = "log_regression"; +static const char __pyx_k_negative_value[] = "negative value"; +static const char __pyx_k_obstacles_edit[] = "obstacles.edit"; +static const char __pyx_k_scipy_optimize[] = "scipy.optimize"; +static const char __pyx_k_StatisticsError[] = "StatisticsError"; +static const char __pyx_k_c_entities_edit[] = "c_entities.edit"; +static const char __pyx_k_mean_derivative[] = "mean_derivative"; +static const char __pyx_k_np_log_z_np_log[] = "* (np.log(z) / np.log("; +static const char __pyx_k_objectives_edit[] = "objectives.edit"; +static const char __pyx_k_obstacles_debug[] = "obstacles.debug"; +static const char __pyx_k_poly_regression[] = "poly_regression"; +static const char __pyx_k_tanh_regression[] = "tanh_regression"; +static const char __pyx_k_as_integer_ratio[] = "as_integer_ratio"; +static const char __pyx_k_c_entities_debug[] = "c_entities.debug"; +static const char __pyx_k_nc_entities_edit[] = "nc_entities.edit"; +static const char __pyx_k_objectives_debug[] = "objectives.debug"; +static const char __pyx_k_obstacles___init[] = "obstacles.__init__"; +static const char __pyx_k_obstacles_append[] = "obstacles.append"; +static const char __pyx_k_obstacles_search[] = "obstacles.search"; +static const char __pyx_k_stdev_derivative[] = "stdev_derivative"; +static const char __pyx_k_c_entities___init[] = "c_entities.__init__"; +static const char __pyx_k_c_entities_append[] = "c_entities.append"; +static const char __pyx_k_c_entities_search[] = "c_entities.search"; +static const char __pyx_k_derivative_sorted[] = "derivative_sorted"; +static const char __pyx_k_nc_entities_debug[] = "nc_entities.debug"; +static const char __pyx_k_objectives___init[] = "objectives.__init__"; +static const char __pyx_k_objectives_append[] = "objectives.append"; +static const char __pyx_k_objectives_search[] = "objectives.search"; +static const char __pyx_k_ss_locals_genexpr[] = "_ss..genexpr"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_nc_entities___init[] = "nc_entities.__init__"; +static const char __pyx_k_nc_entities_append[] = "nc_entities.append"; +static const char __pyx_k_nc_entities_search[] = "nc_entities.search"; +static const char __pyx_k_sum_locals_genexpr[] = "_sum..genexpr"; +static const char __pyx_k_optimize_regression[] = "optimize_regression"; +static const char __pyx_k_could_not_assign_cpu[] = "could not assign cpu"; +static const char __pyx_k_obstacles_regurgitate[] = "obstacles.regurgitate"; +static const char __pyx_k_c_entities_regurgitate[] = "c_entities.regurgitate"; +static const char __pyx_k_initial_type_T_is_bool[] = "initial type T is bool"; +static const char __pyx_k_no_mode_for_empty_data[] = "no mode for empty data"; +static const char __pyx_k_objectives_regurgitate[] = "objectives.regurgitate"; +static const char __pyx_k_resolution_must_be_int[] = "resolution must be int"; +static const char __pyx_k_select_best_regression[] = "select_best_regression"; +static const char __pyx_k_nc_entities_regurgitate[] = "nc_entities.regurgitate"; +static const char __pyx_k_no_median_for_empty_data[] = "no median for empty data"; +static const char __pyx_k_tanh_regression_locals_tanh[] = "tanh_regression..tanh"; +static const char __pyx_k_could_not_assign_cuda_or_cpu[] = "could not assign cuda or cpu"; +static const char __pyx_k_c_entities_has_attributes_names[] = "c_entities has attributes names, ids, positions, properties, and logic. __init__ takes self, 1d array of names, 1d array of ids, 2d array of positions, nd array of properties, and nd array of logic"; +static const char __pyx_k_can_t_convert_type_to_numerator[] = "can't convert type '{}' to numerator/denominator"; +static const char __pyx_k_changelog_1_0_8_005_minor_fixes[] = "changelog:\n1.0.8.005:\n - minor fixes\n1.0.8.004:\n - removed a few unused dependencies\n1.0.8.003:\n - added p_value function\n1.0.8.002:\n - updated __all__ correctly to contain changes made in v 1.0.8.000 and v 1.0.8.001\n1.0.8.001:\n - refactors\n - bugfixes\n1.0.8.000:\n - depreciated histo_analysis_old\n - depreciated debug\n - altered basic_analysis to take array data instead of filepath\n - refactor\n - optimization\n1.0.7.002:\n - bug fixes\n1.0.7.001:\n - bug fixes\n1.0.7.000:\n - added tanh_regression (logistical regression)\n - bug fixes\n1.0.6.005:\n - added z_normalize function to normalize dataset\n - bug fixes\n1.0.6.004:\n - bug fixes\n1.0.6.003:\n - bug fixes\n1.0.6.002:\n - bug fixes\n1.0.6.001:\n - corrected __all__ to contain all of the functions\n1.0.6.000:\n - added calc_overfit, which calculates two measures of overfit, error and performance\n - added calculating overfit to optimize_regression\n1.0.5.000:\n - added optimize_regression function, which is a sample function to find the optimal regressions\n - optimize_regression function filters out some overfit funtions (functions with r^2 = 1)\n - planned addition: overfit detection in the optimize_regression function\n1.0.4.002:\n - added __changelog__\n - updated debug function with log and exponential regressions\n1.0.4.001:\n - added log regressions\n - added exponential regressions\n - added log_regression and exp_regression to __all__\n1.0.3.008:\n - added debug function to further consolidate functions\n1.0.3.007:\n - added builtin benchmark function\n - added builtin random (linear) data generation function\n - added device initialization (_init_device)\n1.0.3.006:\n - reorganized the imports list to be in alphabetical order\n - added search and regurgitate functions to c_entities, nc_entities, obstacles, objectives\n1.0.3.005:\n - major bug fixes\n - updated historical"" analysis\n - depreciated old historical analysis\n1.0.3.004:\n - added __version__, __author__, __all__\n - added polynomial regression\n - added root mean squared function\n - added r squared function\n1.0.3.003:\n - bug fixes\n - added c_entities\n1.0.3.002:\n - bug fixes\n - added nc_entities, obstacles, objectives\n - consolidated statistics.py to analysis.py\n1.0.3.001:\n - compiled 1d, column, and row basic stats into basic stats function\n1.0.3.000:\n - added historical analysis function\n1.0.2.xxx:\n - added z score test\n1.0.1.xxx:\n - major bug fixes\n1.0.0.xxx:\n - added loading csv\n - added 1d, column, row basic stats\n"; +static const char __pyx_k_mean_requires_at_least_one_data[] = "mean requires at least one data point"; +static const char __pyx_k_specified_device_does_not_exist[] = "specified device does not exist"; +static const char __pyx_k_Arthur_Lu_arthurlu_ttic_edu_Jaco[] = "Arthur Lu , Jacob Levine ,"; +static const char __pyx_k_basic_stats_requires_3_args_data[] = "basic_stats requires 3 args: data, mode, arg; where data is data to be analyzed, mode is an int from 0 - 2 depending on type of analysis (by column or by row) and is only applicable to 2d arrays (for 1d arrays use mode 1), and arg is row/column number for mode 1 or mode 2; function returns: [mean, median, mode, stdev, variance]"; +static const char __pyx_k_don_t_know_how_to_coerce_s_and_s[] = "don't know how to coerce %s and %s"; +static const char __pyx_k_nc_entities_non_controlable_enti[] = "nc_entities (non-controlable entities) has attributes names, ids, positions, properties, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of positions, 2d array of properties, and 2d array of effects."; +static const char __pyx_k_negative_sum_of_square_deviation[] = "negative sum of square deviations: %f"; +static const char __pyx_k_no_unique_mode_found_d_equally_c[] = "no unique mode; found %d equally common values"; +static const char __pyx_k_objectives_has_atributes_names_i[] = "objectives has atributes names, ids, positions, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 1d array of effects."; +static const char __pyx_k_obstacles_has_atributes_names_id[] = "obstacles has atributes names, ids, positions, perimeters, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 3d array of perimeters, 2d array of effects."; +static const char __pyx_k_returns_list_of_predicted_values[] = "returns list of predicted values based on historical data; input delta for delta step in z-score and lower and higher bounds in number of standard deviations"; +static const char __pyx_k_variance_requires_at_least_two_d[] = "variance requires at least two data points"; +static PyObject *__pyx_kp_s_; +static PyObject *__pyx_kp_s_1_0_8_005; +static PyObject *__pyx_kp_s_1d; +static PyObject *__pyx_kp_s_Arthur_Lu_arthurlu_ttic_edu_Jaco; +static PyObject *__pyx_n_s_AttributeError; +static PyObject *__pyx_n_s_Counter; +static PyObject *__pyx_n_s_Decimal; +static PyObject *__pyx_n_s_Fraction; +static PyObject *__pyx_n_s_OverflowError; +static PyObject *__pyx_n_s_S; +static PyObject *__pyx_n_s_StatisticsError; +static PyObject *__pyx_n_s_T; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_n_s_U; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_kp_s__10; +static PyObject *__pyx_kp_s__13; +static PyObject *__pyx_kp_s__14; +static PyObject *__pyx_kp_s__15; +static PyObject *__pyx_n_s__17; +static PyObject *__pyx_kp_s__2; +static PyObject *__pyx_kp_s__5; +static PyObject *__pyx_kp_s__6; +static PyObject *__pyx_kp_s__7; +static PyObject *__pyx_kp_s__8; +static PyObject *__pyx_kp_s__9; +static PyObject *__pyx_n_s_a; +static PyObject *__pyx_n_s_adam; +static PyObject *__pyx_n_s_all; +static PyObject *__pyx_n_s_analysis; +static PyObject *__pyx_kp_s_analysis_py; +static PyObject *__pyx_n_s_append; +static PyObject *__pyx_n_s_arg; +static PyObject *__pyx_n_s_argmax; +static PyObject *__pyx_n_s_argmin; +static PyObject *__pyx_n_s_args; +static PyObject *__pyx_n_s_array; +static PyObject *__pyx_n_s_as_integer_ratio; +static PyObject *__pyx_n_s_author; +static PyObject *__pyx_n_s_b; +static PyObject *__pyx_n_s_b_eq; +static PyObject *__pyx_n_s_b_overfit; +static PyObject *__pyx_n_s_b_r2; +static PyObject *__pyx_n_s_b_rms; +static PyObject *__pyx_n_s_base; +static PyObject *__pyx_n_s_basic_analysis; +static PyObject *__pyx_n_s_basic_stats; +static PyObject *__pyx_kp_s_basic_stats_requires_3_args_data; +static PyObject *__pyx_n_s_benchmark; +static PyObject *__pyx_n_s_bisect; +static PyObject *__pyx_n_s_bisect_left; +static PyObject *__pyx_n_s_bisect_right; +static PyObject *__pyx_n_s_both; +static PyObject *__pyx_n_s_builtins; +static PyObject *__pyx_n_s_c; +static PyObject *__pyx_n_s_c_data; +static PyObject *__pyx_n_s_c_data_sorted; +static PyObject *__pyx_n_s_c_effects; +static PyObject *__pyx_n_s_c_entities; +static PyObject *__pyx_n_s_c_entities___init; +static PyObject *__pyx_n_s_c_entities_append; +static PyObject *__pyx_n_s_c_entities_debug; +static PyObject *__pyx_n_s_c_entities_edit; +static PyObject *__pyx_kp_s_c_entities_has_attributes_names; +static PyObject *__pyx_n_s_c_entities_regurgitate; +static PyObject *__pyx_n_s_c_entities_search; +static PyObject *__pyx_n_s_c_ids; +static PyObject *__pyx_n_s_c_logic; +static PyObject *__pyx_n_s_c_names; +static PyObject *__pyx_n_s_c_perim; +static PyObject *__pyx_n_s_c_pos; +static PyObject *__pyx_n_s_c_properties; +static PyObject *__pyx_n_s_calc_overfit; +static PyObject *__pyx_kp_s_can_t_convert_type_to_numerator; +static PyObject *__pyx_n_s_changelog; +static PyObject *__pyx_kp_s_changelog_1_0_8_005_minor_fixes; +static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_n_s_close; +static PyObject *__pyx_n_s_coerce; +static PyObject *__pyx_n_s_collections; +static PyObject *__pyx_n_s_column; +static PyObject *__pyx_n_s_column_b_stats; +static PyObject *__pyx_n_s_column_max; +static PyObject *__pyx_n_s_convert; +static PyObject *__pyx_kp_s_could_not_assign_cpu; +static PyObject *__pyx_kp_s_could_not_assign_cuda_or_cpu; +static PyObject *__pyx_n_s_count; +static PyObject *__pyx_n_s_count2; +static PyObject *__pyx_n_s_counts; +static PyObject *__pyx_n_s_cpu; +static PyObject *__pyx_n_s_csv; +static PyObject *__pyx_n_s_csvfile; +static PyObject *__pyx_n_s_cuda; +static PyObject *__pyx_n_s_curve_fit; +static PyObject *__pyx_n_s_d; +static PyObject *__pyx_n_s_data; +static PyObject *__pyx_kp_s_data_data_csv; +static PyObject *__pyx_n_s_data_t; +static PyObject *__pyx_n_s_debug; +static PyObject *__pyx_n_s_decimal; +static PyObject *__pyx_n_s_deg; +static PyObject *__pyx_n_s_delta; +static PyObject *__pyx_n_s_denominator; +static PyObject *__pyx_n_s_derivative; +static PyObject *__pyx_n_s_derivative_sorted; +static PyObject *__pyx_n_s_device; +static PyObject *__pyx_n_s_doc; +static PyObject *__pyx_kp_s_don_t_know_how_to_coerce_s_and_s; +static PyObject *__pyx_n_s_e; +static PyObject *__pyx_n_s_edit; +static PyObject *__pyx_n_s_effects; +static PyObject *__pyx_n_s_end; +static PyObject *__pyx_n_s_end_a; +static PyObject *__pyx_n_s_end_g; +static PyObject *__pyx_n_s_enter; +static PyObject *__pyx_n_s_eq_str; +static PyObject *__pyx_n_s_eqs; +static PyObject *__pyx_n_s_equation; +static PyObject *__pyx_n_s_errmsg; +static PyObject *__pyx_n_s_error; +static PyObject *__pyx_n_s_eve; +static PyObject *__pyx_n_s_exact_ratio; +static PyObject *__pyx_n_s_exit; +static PyObject *__pyx_n_s_exp_regression; +static PyObject *__pyx_n_s_fail_neg; +static PyObject *__pyx_n_s_file; +static PyObject *__pyx_n_s_file_array; +static PyObject *__pyx_n_s_filename; +static PyObject *__pyx_n_s_filepath; +static PyObject *__pyx_n_s_find_lteq; +static PyObject *__pyx_n_s_find_rteq; +static PyObject *__pyx_n_s_float64; +static PyObject *__pyx_n_s_floor; +static PyObject *__pyx_n_s_format; +static PyObject *__pyx_n_s_fractions; +static PyObject *__pyx_n_s_functools; +static PyObject *__pyx_n_s_generate_data; +static PyObject *__pyx_n_s_genexpr; +static PyObject *__pyx_n_s_get; +static PyObject *__pyx_n_s_groupby; +static PyObject *__pyx_n_s_high; +static PyObject *__pyx_n_s_high_bound; +static PyObject *__pyx_n_s_hist_data; +static PyObject *__pyx_n_s_histo_analysis; +static PyObject *__pyx_n_s_i; +static PyObject *__pyx_n_s_ids; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_ind; +static PyObject *__pyx_n_s_index; +static PyObject *__pyx_n_s_init; +static PyObject *__pyx_n_s_init_device; +static PyObject *__pyx_kp_s_initial_type_T_is_bool; +static PyObject *__pyx_n_s_is_available; +static PyObject *__pyx_n_s_is_finite; +static PyObject *__pyx_n_s_isfinite; +static PyObject *__pyx_n_s_isfinite_2; +static PyObject *__pyx_n_s_items; +static PyObject *__pyx_n_s_itertools; +static PyObject *__pyx_n_s_j; +static PyObject *__pyx_n_s_key; +static PyObject *__pyx_n_s_l; +static PyObject *__pyx_n_s_lo; +static PyObject *__pyx_n_s_load_csv; +static PyObject *__pyx_n_s_log; +static PyObject *__pyx_n_s_log_regression; +static PyObject *__pyx_n_s_logic; +static PyObject *__pyx_n_s_low; +static PyObject *__pyx_n_s_low_bound; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_map; +static PyObject *__pyx_n_s_math; +static PyObject *__pyx_n_s_matplotlib; +static PyObject *__pyx_n_s_max; +static PyObject *__pyx_n_s_max_r2s; +static PyObject *__pyx_n_s_maxfreq; +static PyObject *__pyx_n_s_mean; +static PyObject *__pyx_n_s_mean_2; +static PyObject *__pyx_n_s_mean_derivative; +static PyObject *__pyx_kp_s_mean_requires_at_least_one_data; +static PyObject *__pyx_n_s_median; +static PyObject *__pyx_n_s_median_2; +static PyObject *__pyx_n_s_metaclass; +static PyObject *__pyx_n_s_method; +static PyObject *__pyx_kp_s_method_error; +static PyObject *__pyx_n_s_metrics; +static PyObject *__pyx_n_s_min_overfit; +static PyObject *__pyx_n_s_mode; +static PyObject *__pyx_n_s_mode_2; +static PyObject *__pyx_kp_s_mode_error; +static PyObject *__pyx_n_s_module; +static PyObject *__pyx_n_s_most_common; +static PyObject *__pyx_n_s_msg; +static PyObject *__pyx_n_s_n; +static PyObject *__pyx_n_s_n_effect; +static PyObject *__pyx_n_s_n_id; +static PyObject *__pyx_n_s_n_logic; +static PyObject *__pyx_n_s_n_name; +static PyObject *__pyx_n_s_n_perim; +static PyObject *__pyx_n_s_n_pos; +static PyObject *__pyx_n_s_n_property; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_names; +static PyObject *__pyx_n_s_nc_entities; +static PyObject *__pyx_n_s_nc_entities___init; +static PyObject *__pyx_n_s_nc_entities_append; +static PyObject *__pyx_n_s_nc_entities_debug; +static PyObject *__pyx_n_s_nc_entities_edit; +static PyObject *__pyx_kp_s_nc_entities_non_controlable_enti; +static PyObject *__pyx_n_s_nc_entities_regurgitate; +static PyObject *__pyx_n_s_nc_entities_search; +static PyObject *__pyx_kp_s_negative_sum_of_square_deviation; +static PyObject *__pyx_kp_s_negative_value; +static PyObject *__pyx_n_s_newline; +static PyObject *__pyx_kp_s_no_median_for_empty_data; +static PyObject *__pyx_kp_s_no_mode_for_empty_data; +static PyObject *__pyx_kp_s_no_unique_mode_found_d_equally_c; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_kp_s_np_log_z_np_log; +static PyObject *__pyx_kp_s_np_tanh; +static PyObject *__pyx_n_s_null; +static PyObject *__pyx_n_s_numbers; +static PyObject *__pyx_n_s_numerator; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_n_s_objectives; +static PyObject *__pyx_n_s_objectives___init; +static PyObject *__pyx_n_s_objectives_append; +static PyObject *__pyx_n_s_objectives_debug; +static PyObject *__pyx_n_s_objectives_edit; +static PyObject *__pyx_kp_s_objectives_has_atributes_names_i; +static PyObject *__pyx_n_s_objectives_regurgitate; +static PyObject *__pyx_n_s_objectives_search; +static PyObject *__pyx_n_s_obstacles; +static PyObject *__pyx_n_s_obstacles___init; +static PyObject *__pyx_n_s_obstacles_append; +static PyObject *__pyx_n_s_obstacles_debug; +static PyObject *__pyx_n_s_obstacles_edit; +static PyObject *__pyx_kp_s_obstacles_has_atributes_names_id; +static PyObject *__pyx_n_s_obstacles_regurgitate; +static PyObject *__pyx_n_s_obstacles_search; +static PyObject *__pyx_n_s_open; +static PyObject *__pyx_n_s_optimize_regression; +static PyObject *__pyx_n_s_overfit; +static PyObject *__pyx_n_s_p_value; +static PyObject *__pyx_n_s_pandas; +static PyObject *__pyx_n_s_partials; +static PyObject *__pyx_n_s_partials_get; +static PyObject *__pyx_n_s_perims; +static PyObject *__pyx_n_s_pi; +static PyObject *__pyx_n_s_point; +static PyObject *__pyx_n_s_poly_regression; +static PyObject *__pyx_n_s_polyfit; +static PyObject *__pyx_n_s_pop; +static PyObject *__pyx_n_s_pos; +static PyObject *__pyx_n_s_position; +static PyObject *__pyx_n_s_power; +static PyObject *__pyx_n_s_pred_change; +static PyObject *__pyx_n_s_predictions; +static PyObject *__pyx_n_s_prepare; +static PyObject *__pyx_n_s_print; +static PyObject *__pyx_n_s_properties; +static PyObject *__pyx_n_s_q_str; +static PyObject *__pyx_n_s_qualname; +static PyObject *__pyx_n_s_r2_d2; +static PyObject *__pyx_n_s_r2_score; +static PyObject *__pyx_n_s_r2_test; +static PyObject *__pyx_n_s_r2_train; +static PyObject *__pyx_n_s_r2s; +static PyObject *__pyx_n_s_r_data; +static PyObject *__pyx_n_s_r_squared; +static PyObject *__pyx_n_s_randint; +static PyObject *__pyx_n_s_random; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_range_2; +static PyObject *__pyx_n_s_reader; +static PyObject *__pyx_n_s_reg_eq; +static PyObject *__pyx_n_s_regurgitate; +static PyObject *__pyx_n_s_remove; +static PyObject *__pyx_n_s_resolution; +static PyObject *__pyx_kp_s_resolution_must_be_int; +static PyObject *__pyx_kp_s_returns_list_of_predicted_values; +static PyObject *__pyx_n_s_rms; +static PyObject *__pyx_n_s_rms_2; +static PyObject *__pyx_n_s_rms_test; +static PyObject *__pyx_n_s_rms_train; +static PyObject *__pyx_n_s_rmss; +static PyObject *__pyx_n_s_row; +static PyObject *__pyx_n_s_row_b_stats; +static PyObject *__pyx_n_s_row_histo; +static PyObject *__pyx_n_s_scipy; +static PyObject *__pyx_n_s_scipy_optimize; +static PyObject *__pyx_n_s_score; +static PyObject *__pyx_n_s_search; +static PyObject *__pyx_n_s_select_best_regression; +static PyObject *__pyx_n_s_selector; +static PyObject *__pyx_n_s_self; +static PyObject *__pyx_n_s_send; +static PyObject *__pyx_n_s_setting; +static PyObject *__pyx_n_s_sklearn; +static PyObject *__pyx_n_s_sorted; +static PyObject *__pyx_kp_s_specified_device_does_not_exist; +static PyObject *__pyx_n_s_sqrt; +static PyObject *__pyx_n_s_ss; +static PyObject *__pyx_n_s_ss_2; +static PyObject *__pyx_n_s_ss_locals_genexpr; +static PyObject *__pyx_n_s_start; +static PyObject *__pyx_n_s_start_a; +static PyObject *__pyx_n_s_start_g; +static PyObject *__pyx_n_s_stats; +static PyObject *__pyx_n_s_stdev; +static PyObject *__pyx_n_s_stdev_2; +static PyObject *__pyx_n_s_stdev_derivative; +static PyObject *__pyx_n_s_stdev_z_split; +static PyObject *__pyx_n_s_strip_data; +static PyObject *__pyx_n_s_sum; +static PyObject *__pyx_n_s_sum_2; +static PyObject *__pyx_n_s_sum_locals_genexpr; +static PyObject *__pyx_n_s_table; +static PyObject *__pyx_n_s_tanh; +static PyObject *__pyx_n_s_tanh_regression; +static PyObject *__pyx_n_s_tanh_regression_locals_tanh; +static PyObject *__pyx_n_s_targets; +static PyObject *__pyx_n_s_temp; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_throw; +static PyObject *__pyx_n_s_time; +static PyObject *__pyx_n_s_tolist; +static PyObject *__pyx_n_s_torch; +static PyObject *__pyx_n_s_total; +static PyObject *__pyx_n_s_total2; +static PyObject *__pyx_n_s_ttest_ind; +static PyObject *__pyx_n_s_typ; +static PyObject *__pyx_n_s_uniform; +static PyObject *__pyx_n_s_vals; +static PyObject *__pyx_kp_s_vals_append; +static PyObject *__pyx_n_s_value; +static PyObject *__pyx_n_s_values; +static PyObject *__pyx_n_s_var; +static PyObject *__pyx_n_s_variance; +static PyObject *__pyx_n_s_variance_2; +static PyObject *__pyx_kp_s_variance_requires_at_least_two_d; +static PyObject *__pyx_n_s_version; +static PyObject *__pyx_n_s_w; +static PyObject *__pyx_n_s_write; +static PyObject *__pyx_n_s_x; +static PyObject *__pyx_n_s_x_fit; +static PyObject *__pyx_n_s_x_norm; +static PyObject *__pyx_n_s_x_test; +static PyObject *__pyx_n_s_x_train; +static PyObject *__pyx_n_s_xbar; +static PyObject *__pyx_n_s_y; +static PyObject *__pyx_n_s_y_fit; +static PyObject *__pyx_n_s_y_norm; +static PyObject *__pyx_n_s_y_test; +static PyObject *__pyx_n_s_y_train; +static PyObject *__pyx_kp_s_z; +static PyObject *__pyx_n_s_z_2; +static PyObject *__pyx_kp_s_z_3; +static PyObject *__pyx_kp_s_z_4; +static PyObject *__pyx_n_s_z_normalize; +static PyObject *__pyx_n_s_z_score; +static PyObject *__pyx_n_s_z_split; +static PyObject *__pyx_pf_8analysis__init_device(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_setting, PyObject *__pyx_v_arg); /* proto */ +static PyObject *__pyx_pf_8analysis_10c_entities_debug(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_8analysis_10c_entities_2__init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_names, PyObject *__pyx_v_ids, PyObject *__pyx_v_pos, PyObject *__pyx_v_properties, PyObject *__pyx_v_logic); /* proto */ +static PyObject *__pyx_pf_8analysis_10c_entities_4append(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_pos, PyObject *__pyx_v_n_property, PyObject *__pyx_v_n_logic); /* proto */ +static PyObject *__pyx_pf_8analysis_10c_entities_6edit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_pos, PyObject *__pyx_v_n_property, PyObject *__pyx_v_n_logic); /* proto */ +static PyObject *__pyx_pf_8analysis_10c_entities_8search(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search); /* proto */ +static PyObject *__pyx_pf_8analysis_10c_entities_10regurgitate(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_8analysis_11nc_entities_debug(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_8analysis_11nc_entities_2__init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_names, PyObject *__pyx_v_ids, PyObject *__pyx_v_pos, PyObject *__pyx_v_properties, PyObject *__pyx_v_effects); /* proto */ +static PyObject *__pyx_pf_8analysis_11nc_entities_4append(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_pos, PyObject *__pyx_v_n_property, PyObject *__pyx_v_n_effect); /* proto */ +static PyObject *__pyx_pf_8analysis_11nc_entities_6edit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_pos, PyObject *__pyx_v_n_property, PyObject *__pyx_v_n_effect); /* proto */ +static PyObject *__pyx_pf_8analysis_11nc_entities_8search(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search); /* proto */ +static PyObject *__pyx_pf_8analysis_11nc_entities_10regurgitate(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_8analysis_9obstacles_debug(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_8analysis_9obstacles_2__init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_names, PyObject *__pyx_v_ids, PyObject *__pyx_v_perims, PyObject *__pyx_v_effects); /* proto */ +static PyObject *__pyx_pf_8analysis_9obstacles_4append(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_perim, PyObject *__pyx_v_n_effect); /* proto */ +static PyObject *__pyx_pf_8analysis_9obstacles_6edit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_perim, PyObject *__pyx_v_n_effect); /* proto */ +static PyObject *__pyx_pf_8analysis_9obstacles_8search(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search); /* proto */ +static PyObject *__pyx_pf_8analysis_9obstacles_10regurgitate(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_8analysis_10objectives_debug(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_8analysis_10objectives_2__init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_names, PyObject *__pyx_v_ids, PyObject *__pyx_v_pos, PyObject *__pyx_v_effects); /* proto */ +static PyObject *__pyx_pf_8analysis_10objectives_4append(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_pos, PyObject *__pyx_v_n_effect); /* proto */ +static PyObject *__pyx_pf_8analysis_10objectives_6edit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_pos, PyObject *__pyx_v_n_effect); /* proto */ +static PyObject *__pyx_pf_8analysis_10objectives_8search(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search); /* proto */ +static PyObject *__pyx_pf_8analysis_10objectives_10regurgitate(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_8analysis_2load_csv(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_filepath); /* proto */ +static PyObject *__pyx_pf_8analysis_4basic_stats(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data, PyObject *__pyx_v_method, PyObject *__pyx_v_arg); /* proto */ +static PyObject *__pyx_pf_8analysis_6z_score(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_point, PyObject *__pyx_v_mean, PyObject *__pyx_v_stdev); /* proto */ +static PyObject *__pyx_pf_8analysis_8z_normalize(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y, PyObject *__pyx_v_mode); /* proto */ +static PyObject *__pyx_pf_8analysis_10stdev_z_split(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_mean, PyObject *__pyx_v_stdev, PyObject *__pyx_v_delta, PyObject *__pyx_v_low_bound, PyObject *__pyx_v_high_bound); /* proto */ +static PyObject *__pyx_pf_8analysis_12histo_analysis(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_hist_data, PyObject *__pyx_v_delta, PyObject *__pyx_v_low_bound, PyObject *__pyx_v_high_bound); /* proto */ +static PyObject *__pyx_pf_8analysis_14poly_regression(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y, PyObject *__pyx_v_power); /* proto */ +static PyObject *__pyx_pf_8analysis_16log_regression(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y, PyObject *__pyx_v_base); /* proto */ +static PyObject *__pyx_pf_8analysis_18exp_regression(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y, PyObject *__pyx_v_base); /* proto */ +static PyObject *__pyx_pf_8analysis_15tanh_regression_tanh(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d); /* proto */ +static PyObject *__pyx_pf_8analysis_20tanh_regression(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y); /* proto */ +static PyObject *__pyx_pf_8analysis_22r_squared(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_predictions, PyObject *__pyx_v_targets); /* proto */ +static PyObject *__pyx_pf_8analysis_24rms(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_predictions, PyObject *__pyx_v_targets); /* proto */ +static PyObject *__pyx_pf_8analysis_26calc_overfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_equation, PyObject *__pyx_v_rms_train, PyObject *__pyx_v_r2_train, PyObject *__pyx_v_x_test, PyObject *__pyx_v_y_test); /* proto */ +static PyObject *__pyx_pf_8analysis_28strip_data(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_data, PyObject *__pyx_v_mode); /* proto */ +static PyObject *__pyx_pf_8analysis_30optimize_regression(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y, PyObject *__pyx_v__range, PyObject *__pyx_v_resolution); /* proto */ +static PyObject *__pyx_pf_8analysis_32select_best_regression(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_eqs, PyObject *__pyx_v_rmss, PyObject *__pyx_v_r2s, PyObject *__pyx_v_overfit, PyObject *__pyx_v_selector); /* proto */ +static PyObject *__pyx_pf_8analysis_34p_value(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y); /* proto */ +static PyObject *__pyx_pf_8analysis_36basic_analysis(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data); /* proto */ +static PyObject *__pyx_pf_8analysis_38benchmark(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y); /* proto */ +static PyObject *__pyx_pf_8analysis_40generate_data(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_x, PyObject *__pyx_v_y, PyObject *__pyx_v_low, PyObject *__pyx_v_high); /* proto */ +static PyObject *__pyx_pf_8analysis_4_sum_genexpr(PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_8analysis_42_sum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data, PyObject *__pyx_v_start); /* proto */ +static PyObject *__pyx_pf_8analysis_44_isfinite(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_8analysis_46_coerce(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_T, PyObject *__pyx_v_S); /* proto */ +static PyObject *__pyx_pf_8analysis_48_exact_ratio(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_8analysis_50_convert(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_value, PyObject *__pyx_v_T); /* proto */ +static PyObject *__pyx_pf_8analysis_52_counts(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data); /* proto */ +static PyObject *__pyx_pf_8analysis_54_find_lteq(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_a, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_8analysis_56_find_rteq(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_a, PyObject *__pyx_v_l, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_8analysis_58_fail_neg(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_values, PyObject *__pyx_v_errmsg); /* proto */ +static PyObject *__pyx_pf_8analysis_61mean(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data); /* proto */ +static PyObject *__pyx_pf_8analysis_63median(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data); /* proto */ +static PyObject *__pyx_pf_8analysis_65mode(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data); /* proto */ +static PyObject *__pyx_pf_8analysis_3_ss_genexpr(PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_8analysis_3_ss_3genexpr(PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_8analysis_67_ss(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data, PyObject *__pyx_v_c); /* proto */ +static PyObject *__pyx_pf_8analysis_69variance(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data, PyObject *__pyx_v_xbar); /* proto */ +static PyObject *__pyx_pf_8analysis_71stdev(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data, PyObject *__pyx_v_xbar); /* proto */ +static PyObject *__pyx_tp_new_8analysis___pyx_scope_struct___sum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_8analysis___pyx_scope_struct_1_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_8analysis___pyx_scope_struct_2__fail_neg(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_8analysis___pyx_scope_struct_3__ss(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_8analysis___pyx_scope_struct_4_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_8analysis___pyx_scope_struct_5_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_get = {0, &__pyx_n_s_get, 0, 0, 0}; +static __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items = {0, &__pyx_n_s_items, 0, 0, 0}; +static __Pyx_CachedCFunction __pyx_umethod_PyList_Type_remove = {0, &__pyx_n_s_remove, 0, 0, 0}; +static PyObject *__pyx_float_0_67449; +static PyObject *__pyx_float_neg_0_5; +static PyObject *__pyx_float_neg_0_67449; +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_2; +static PyObject *__pyx_int_10; +static PyObject *__pyx_int_100; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_int_neg_10; +static PyObject *__pyx_slice__4; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__18; +static PyObject *__pyx_tuple__19; +static PyObject *__pyx_tuple__21; +static PyObject *__pyx_tuple__23; +static PyObject *__pyx_tuple__25; +static PyObject *__pyx_tuple__27; +static PyObject *__pyx_tuple__29; +static PyObject *__pyx_tuple__31; +static PyObject *__pyx_tuple__33; +static PyObject *__pyx_tuple__35; +static PyObject *__pyx_tuple__37; +static PyObject *__pyx_tuple__39; +static PyObject *__pyx_tuple__41; +static PyObject *__pyx_tuple__43; +static PyObject *__pyx_tuple__45; +static PyObject *__pyx_tuple__47; +static PyObject *__pyx_tuple__49; +static PyObject *__pyx_tuple__51; +static PyObject *__pyx_tuple__53; +static PyObject *__pyx_tuple__55; +static PyObject *__pyx_tuple__57; +static PyObject *__pyx_tuple__59; +static PyObject *__pyx_tuple__61; +static PyObject *__pyx_tuple__63; +static PyObject *__pyx_tuple__65; +static PyObject *__pyx_tuple__67; +static PyObject *__pyx_tuple__69; +static PyObject *__pyx_tuple__71; +static PyObject *__pyx_tuple__73; +static PyObject *__pyx_tuple__75; +static PyObject *__pyx_tuple__77; +static PyObject *__pyx_tuple__79; +static PyObject *__pyx_tuple__81; +static PyObject *__pyx_tuple__83; +static PyObject *__pyx_tuple__85; +static PyObject *__pyx_tuple__87; +static PyObject *__pyx_tuple__89; +static PyObject *__pyx_tuple__91; +static PyObject *__pyx_tuple__93; +static PyObject *__pyx_tuple__95; +static PyObject *__pyx_tuple__97; +static PyObject *__pyx_tuple__99; +static PyObject *__pyx_tuple__101; +static PyObject *__pyx_tuple__103; +static PyObject *__pyx_tuple__105; +static PyObject *__pyx_tuple__107; +static PyObject *__pyx_tuple__109; +static PyObject *__pyx_tuple__110; +static PyObject *__pyx_tuple__112; +static PyObject *__pyx_tuple__113; +static PyObject *__pyx_tuple__115; +static PyObject *__pyx_tuple__117; +static PyObject *__pyx_tuple__119; +static PyObject *__pyx_tuple__121; +static PyObject *__pyx_tuple__123; +static PyObject *__pyx_tuple__125; +static PyObject *__pyx_tuple__127; +static PyObject *__pyx_tuple__128; +static PyObject *__pyx_tuple__129; +static PyObject *__pyx_tuple__131; +static PyObject *__pyx_tuple__133; +static PyObject *__pyx_tuple__135; +static PyObject *__pyx_tuple__137; +static PyObject *__pyx_tuple__138; +static PyObject *__pyx_tuple__140; +static PyObject *__pyx_tuple__141; +static PyObject *__pyx_tuple__143; +static PyObject *__pyx_codeobj__12; +static PyObject *__pyx_codeobj__16; +static PyObject *__pyx_codeobj__20; +static PyObject *__pyx_codeobj__22; +static PyObject *__pyx_codeobj__24; +static PyObject *__pyx_codeobj__26; +static PyObject *__pyx_codeobj__28; +static PyObject *__pyx_codeobj__30; +static PyObject *__pyx_codeobj__32; +static PyObject *__pyx_codeobj__34; +static PyObject *__pyx_codeobj__36; +static PyObject *__pyx_codeobj__38; +static PyObject *__pyx_codeobj__40; +static PyObject *__pyx_codeobj__42; +static PyObject *__pyx_codeobj__44; +static PyObject *__pyx_codeobj__46; +static PyObject *__pyx_codeobj__48; +static PyObject *__pyx_codeobj__50; +static PyObject *__pyx_codeobj__52; +static PyObject *__pyx_codeobj__54; +static PyObject *__pyx_codeobj__56; +static PyObject *__pyx_codeobj__58; +static PyObject *__pyx_codeobj__60; +static PyObject *__pyx_codeobj__62; +static PyObject *__pyx_codeobj__64; +static PyObject *__pyx_codeobj__66; +static PyObject *__pyx_codeobj__68; +static PyObject *__pyx_codeobj__70; +static PyObject *__pyx_codeobj__72; +static PyObject *__pyx_codeobj__74; +static PyObject *__pyx_codeobj__76; +static PyObject *__pyx_codeobj__78; +static PyObject *__pyx_codeobj__80; +static PyObject *__pyx_codeobj__82; +static PyObject *__pyx_codeobj__84; +static PyObject *__pyx_codeobj__86; +static PyObject *__pyx_codeobj__88; +static PyObject *__pyx_codeobj__90; +static PyObject *__pyx_codeobj__92; +static PyObject *__pyx_codeobj__94; +static PyObject *__pyx_codeobj__96; +static PyObject *__pyx_codeobj__98; +static PyObject *__pyx_codeobj__100; +static PyObject *__pyx_codeobj__102; +static PyObject *__pyx_codeobj__104; +static PyObject *__pyx_codeobj__106; +static PyObject *__pyx_codeobj__108; +static PyObject *__pyx_codeobj__111; +static PyObject *__pyx_codeobj__114; +static PyObject *__pyx_codeobj__116; +static PyObject *__pyx_codeobj__118; +static PyObject *__pyx_codeobj__120; +static PyObject *__pyx_codeobj__122; +static PyObject *__pyx_codeobj__124; +static PyObject *__pyx_codeobj__126; +static PyObject *__pyx_codeobj__130; +static PyObject *__pyx_codeobj__132; +static PyObject *__pyx_codeobj__134; +static PyObject *__pyx_codeobj__136; +static PyObject *__pyx_codeobj__139; +static PyObject *__pyx_codeobj__142; +/* Late includes */ + +/* "analysis.py":161 + * + * + * def _init_device(setting, arg): # initiates computation device for ANNs # <<<<<<<<<<<<<< + * if setting == "cuda": + * try: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_1_init_device(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_1_init_device = {"_init_device", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_1_init_device, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_1_init_device(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_setting = 0; + PyObject *__pyx_v_arg = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_init_device (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_setting,&__pyx_n_s_arg,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_setting)) != 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_arg)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_init_device", 1, 2, 2, 1); __PYX_ERR(0, 161, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_init_device") < 0)) __PYX_ERR(0, 161, __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_setting = values[0]; + __pyx_v_arg = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_init_device", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 161, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis._init_device", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis__init_device(__pyx_self, __pyx_v_setting, __pyx_v_arg); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis__init_device(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_setting, PyObject *__pyx_v_arg) { + 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; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + __Pyx_RefNannySetupContext("_init_device", 0); + + /* "analysis.py":162 + * + * def _init_device(setting, arg): # initiates computation device for ANNs + * if setting == "cuda": # <<<<<<<<<<<<<< + * try: + * return torch.device(setting + ":" + str(arg) if torch.cuda.is_available() else "cpu") + */ + __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_setting, __pyx_n_s_cuda, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 162, __pyx_L1_error) + if (__pyx_t_1) { + + /* "analysis.py":163 + * def _init_device(setting, arg): # initiates computation device for ANNs + * if setting == "cuda": + * try: # <<<<<<<<<<<<<< + * return torch.device(setting + ":" + str(arg) if torch.cuda.is_available() else "cpu") + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + /*try:*/ { + + /* "analysis.py":164 + * if setting == "cuda": + * try: + * return torch.device(setting + ":" + str(arg) if torch.cuda.is_available() else "cpu") # <<<<<<<<<<<<<< + * except: + * raise error("could not assign cuda or cpu") + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_torch); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 164, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_device); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 164, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_torch); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 164, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_cuda); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 164, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_is_available); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 164, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + __pyx_t_8 = (__pyx_t_10) ? __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_10) : __Pyx_PyObject_CallNoArg(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 164, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 164, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_1) { + __pyx_t_8 = PyNumber_Add(__pyx_v_setting, __pyx_kp_s_); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 164, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_v_arg); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 164, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = PyNumber_Add(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 164, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_6 = __pyx_t_10; + __pyx_t_10 = 0; + } else { + __Pyx_INCREF(__pyx_n_s_cpu); + __pyx_t_6 = __pyx_n_s_cpu; + } + __pyx_t_10 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_5 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_10, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 164, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L8_try_return; + + /* "analysis.py":163 + * def _init_device(setting, arg): # initiates computation device for ANNs + * if setting == "cuda": + * try: # <<<<<<<<<<<<<< + * return torch.device(setting + ":" + str(arg) if torch.cuda.is_available() else "cpu") + * except: + */ + } + __pyx_L4_error:; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __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_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":165 + * try: + * return torch.device(setting + ":" + str(arg) if torch.cuda.is_available() else "cpu") + * except: # <<<<<<<<<<<<<< + * raise error("could not assign cuda or cpu") + * elif setting == "cpu": + */ + /*except:*/ { + __Pyx_AddTraceback("analysis._init_device", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_7, &__pyx_t_6) < 0) __PYX_ERR(0, 165, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_6); + + /* "analysis.py":166 + * return torch.device(setting + ":" + str(arg) if torch.cuda.is_available() else "cpu") + * except: + * raise error("could not assign cuda or cpu") # <<<<<<<<<<<<<< + * elif setting == "cpu": + * try: + */ + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_error); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 166, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_8, __pyx_kp_s_could_not_assign_cuda_or_cpu) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_kp_s_could_not_assign_cuda_or_cpu); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 166, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(0, 166, __pyx_L6_except_error) + } + __pyx_L6_except_error:; + + /* "analysis.py":163 + * def _init_device(setting, arg): # initiates computation device for ANNs + * if setting == "cuda": + * try: # <<<<<<<<<<<<<< + * return torch.device(setting + ":" + str(arg) if torch.cuda.is_available() else "cpu") + * except: + */ + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L1_error; + __pyx_L8_try_return:; + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L0; + } + + /* "analysis.py":162 + * + * def _init_device(setting, arg): # initiates computation device for ANNs + * if setting == "cuda": # <<<<<<<<<<<<<< + * try: + * return torch.device(setting + ":" + str(arg) if torch.cuda.is_available() else "cpu") + */ + } + + /* "analysis.py":167 + * except: + * raise error("could not assign cuda or cpu") + * elif setting == "cpu": # <<<<<<<<<<<<<< + * try: + * return torch.device("cpu") + */ + __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_setting, __pyx_n_s_cpu, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 167, __pyx_L1_error) + if (likely(__pyx_t_1)) { + + /* "analysis.py":168 + * raise error("could not assign cuda or cpu") + * elif setting == "cpu": + * try: # <<<<<<<<<<<<<< + * return torch.device("cpu") + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_3, &__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_2); + /*try:*/ { + + /* "analysis.py":169 + * elif setting == "cpu": + * try: + * return torch.device("cpu") # <<<<<<<<<<<<<< + * except: + * raise error("could not assign cpu") + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_torch); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 169, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_device); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 169, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_6 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_n_s_cpu) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_s_cpu); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 169, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L16_try_return; + + /* "analysis.py":168 + * raise error("could not assign cuda or cpu") + * elif setting == "cpu": + * try: # <<<<<<<<<<<<<< + * return torch.device("cpu") + * except: + */ + } + __pyx_L12_error:; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __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_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":170 + * try: + * return torch.device("cpu") + * except: # <<<<<<<<<<<<<< + * raise error("could not assign cpu") + * else: + */ + /*except:*/ { + __Pyx_AddTraceback("analysis._init_device", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_7) < 0) __PYX_ERR(0, 170, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_7); + + /* "analysis.py":171 + * return torch.device("cpu") + * except: + * raise error("could not assign cpu") # <<<<<<<<<<<<<< + * else: + * raise error("specified device does not exist") + */ + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_error); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 171, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_8, __pyx_kp_s_could_not_assign_cpu) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_kp_s_could_not_assign_cpu); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 171, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(0, 171, __pyx_L14_except_error) + } + __pyx_L14_except_error:; + + /* "analysis.py":168 + * raise error("could not assign cuda or cpu") + * elif setting == "cpu": + * try: # <<<<<<<<<<<<<< + * return torch.device("cpu") + * except: + */ + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_3, __pyx_t_2); + goto __pyx_L1_error; + __pyx_L16_try_return:; + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_3, __pyx_t_2); + goto __pyx_L0; + } + + /* "analysis.py":167 + * except: + * raise error("could not assign cuda or cpu") + * elif setting == "cpu": # <<<<<<<<<<<<<< + * try: + * return torch.device("cpu") + */ + } + + /* "analysis.py":173 + * raise error("could not assign cpu") + * else: + * raise error("specified device does not exist") # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_7 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_kp_s_specified_device_does_not_exist) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_kp_s_specified_device_does_not_exist); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 173, __pyx_L1_error) + } + + /* "analysis.py":161 + * + * + * def _init_device(setting, arg): # initiates computation device for ANNs # <<<<<<<<<<<<<< + * if setting == "cuda": + * try: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __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("analysis._init_device", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":184 + * c_logic = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("c_entities has attributes names, ids, positions, properties, and logic. __init__ takes self, 1d array of names, 1d array of ids, 2d array of positions, nd array of properties, and nd array of logic") + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_10c_entities_1debug(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_10c_entities_1debug = {"debug", (PyCFunction)__pyx_pw_8analysis_10c_entities_1debug, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_10c_entities_1debug(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("debug (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_10c_entities_debug(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_10c_entities_debug(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + 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; + __Pyx_RefNannySetupContext("debug", 0); + + /* "analysis.py":185 + * + * def debug(self): + * print("c_entities has attributes names, ids, positions, properties, and logic. __init__ takes self, 1d array of names, 1d array of ids, 2d array of positions, nd array of properties, and nd array of logic") # <<<<<<<<<<<<<< + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] + * + */ + if (__Pyx_PrintOne(0, __pyx_kp_s_c_entities_has_attributes_names) < 0) __PYX_ERR(0, 185, __pyx_L1_error) + + /* "analysis.py":186 + * def debug(self): + * print("c_entities has attributes names, ids, positions, properties, and logic. __init__ takes self, 1d array of names, 1d array of ids, 2d array of positions, nd array of properties, and nd array of logic") + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] # <<<<<<<<<<<<<< + * + * def __init__(self, names, ids, pos, properties, logic): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_properties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_logic); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyList_New(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_1); + PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyList_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyList_SET_ITEM(__pyx_t_6, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_6, 3, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyList_SET_ITEM(__pyx_t_6, 4, __pyx_t_5); + __pyx_t_1 = 0; + __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; + + /* "analysis.py":184 + * c_logic = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("c_entities has attributes names, ids, positions, properties, and logic. __init__ takes self, 1d array of names, 1d array of ids, 2d array of positions, nd array of properties, and nd array of logic") + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] + */ + + /* 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("analysis.c_entities.debug", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":188 + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] + * + * def __init__(self, names, ids, pos, properties, logic): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_10c_entities_3__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_10c_entities_3__init__ = {"__init__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_10c_entities_3__init__, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_10c_entities_3__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_names = 0; + PyObject *__pyx_v_ids = 0; + PyObject *__pyx_v_pos = 0; + PyObject *__pyx_v_properties = 0; + PyObject *__pyx_v_logic = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_names,&__pyx_n_s_ids,&__pyx_n_s_pos,&__pyx_n_s_properties,&__pyx_n_s_logic,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_self)) != 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_names)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 1); __PYX_ERR(0, 188, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ids)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 2); __PYX_ERR(0, 188, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pos)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 3); __PYX_ERR(0, 188, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_properties)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 4); __PYX_ERR(0, 188, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_logic)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 5); __PYX_ERR(0, 188, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 188, __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_self = values[0]; + __pyx_v_names = values[1]; + __pyx_v_ids = values[2]; + __pyx_v_pos = values[3]; + __pyx_v_properties = values[4]; + __pyx_v_logic = values[5]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 188, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.c_entities.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_10c_entities_2__init__(__pyx_self, __pyx_v_self, __pyx_v_names, __pyx_v_ids, __pyx_v_pos, __pyx_v_properties, __pyx_v_logic); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_10c_entities_2__init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_names, PyObject *__pyx_v_ids, PyObject *__pyx_v_pos, PyObject *__pyx_v_properties, PyObject *__pyx_v_logic) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__", 0); + + /* "analysis.py":189 + * + * def __init__(self, names, ids, pos, properties, logic): + * self.c_names = names # <<<<<<<<<<<<<< + * self.c_ids = ids + * self.c_pos = pos + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_names, __pyx_v_names) < 0) __PYX_ERR(0, 189, __pyx_L1_error) + + /* "analysis.py":190 + * def __init__(self, names, ids, pos, properties, logic): + * self.c_names = names + * self.c_ids = ids # <<<<<<<<<<<<<< + * self.c_pos = pos + * self.c_properties = properties + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_ids, __pyx_v_ids) < 0) __PYX_ERR(0, 190, __pyx_L1_error) + + /* "analysis.py":191 + * self.c_names = names + * self.c_ids = ids + * self.c_pos = pos # <<<<<<<<<<<<<< + * self.c_properties = properties + * self.c_logic = logic + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_pos, __pyx_v_pos) < 0) __PYX_ERR(0, 191, __pyx_L1_error) + + /* "analysis.py":192 + * self.c_ids = ids + * self.c_pos = pos + * self.c_properties = properties # <<<<<<<<<<<<<< + * self.c_logic = logic + * return None + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_properties, __pyx_v_properties) < 0) __PYX_ERR(0, 192, __pyx_L1_error) + + /* "analysis.py":193 + * self.c_pos = pos + * self.c_properties = properties + * self.c_logic = logic # <<<<<<<<<<<<<< + * return None + * + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_logic, __pyx_v_logic) < 0) __PYX_ERR(0, 193, __pyx_L1_error) + + /* "analysis.py":194 + * self.c_properties = properties + * self.c_logic = logic + * return None # <<<<<<<<<<<<<< + * + * def append(self, n_name, n_id, n_pos, n_property, n_logic): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "analysis.py":188 + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] + * + * def __init__(self, names, ids, pos, properties, logic): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("analysis.c_entities.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":196 + * return None + * + * def append(self, n_name, n_id, n_pos, n_property, n_logic): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_10c_entities_5append(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_10c_entities_5append = {"append", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_10c_entities_5append, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_10c_entities_5append(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_n_name = 0; + PyObject *__pyx_v_n_id = 0; + PyObject *__pyx_v_n_pos = 0; + PyObject *__pyx_v_n_property = 0; + PyObject *__pyx_v_n_logic = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("append (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_n_name,&__pyx_n_s_n_id,&__pyx_n_s_n_pos,&__pyx_n_s_n_property,&__pyx_n_s_n_logic,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_self)) != 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_name)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 6, 6, 1); __PYX_ERR(0, 196, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_id)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 6, 6, 2); __PYX_ERR(0, 196, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pos)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 6, 6, 3); __PYX_ERR(0, 196, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_property)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 6, 6, 4); __PYX_ERR(0, 196, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_logic)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 6, 6, 5); __PYX_ERR(0, 196, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "append") < 0)) __PYX_ERR(0, 196, __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_self = values[0]; + __pyx_v_n_name = values[1]; + __pyx_v_n_id = values[2]; + __pyx_v_n_pos = values[3]; + __pyx_v_n_property = values[4]; + __pyx_v_n_logic = values[5]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("append", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 196, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.c_entities.append", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_10c_entities_4append(__pyx_self, __pyx_v_self, __pyx_v_n_name, __pyx_v_n_id, __pyx_v_n_pos, __pyx_v_n_property, __pyx_v_n_logic); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_10c_entities_4append(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_pos, PyObject *__pyx_v_n_property, PyObject *__pyx_v_n_logic) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + __Pyx_RefNannySetupContext("append", 0); + + /* "analysis.py":197 + * + * def append(self, n_name, n_id, n_pos, n_property, n_logic): + * self.c_names.append(n_name) # <<<<<<<<<<<<<< + * self.c_ids.append(n_id) + * self.c_pos.append(n_pos) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_name); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":198 + * def append(self, n_name, n_id, n_pos, n_property, n_logic): + * self.c_names.append(n_name) + * self.c_ids.append(n_id) # <<<<<<<<<<<<<< + * self.c_pos.append(n_pos) + * self.c_properties.append(n_property) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_id); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":199 + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + * self.c_pos.append(n_pos) # <<<<<<<<<<<<<< + * self.c_properties.append(n_property) + * self.c_logic.append(n_logic) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_pos); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":200 + * self.c_ids.append(n_id) + * self.c_pos.append(n_pos) + * self.c_properties.append(n_property) # <<<<<<<<<<<<<< + * self.c_logic.append(n_logic) + * return None + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_properties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_property); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":201 + * self.c_pos.append(n_pos) + * self.c_properties.append(n_property) + * self.c_logic.append(n_logic) # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_logic); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_logic); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":202 + * self.c_properties.append(n_property) + * self.c_logic.append(n_logic) + * return None # <<<<<<<<<<<<<< + * + * def edit(self, search, n_name, n_id, n_pos, n_property, n_logic): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "analysis.py":196 + * return None + * + * def append(self, n_name, n_id, n_pos, n_property, n_logic): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("analysis.c_entities.append", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":204 + * return None + * + * def edit(self, search, n_name, n_id, n_pos, n_property, n_logic): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_10c_entities_7edit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_10c_entities_7edit = {"edit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_10c_entities_7edit, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_10c_entities_7edit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_search = 0; + PyObject *__pyx_v_n_name = 0; + PyObject *__pyx_v_n_id = 0; + PyObject *__pyx_v_n_pos = 0; + PyObject *__pyx_v_n_property = 0; + PyObject *__pyx_v_n_logic = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("edit (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_search,&__pyx_n_s_n_name,&__pyx_n_s_n_id,&__pyx_n_s_n_pos,&__pyx_n_s_n_property,&__pyx_n_s_n_logic,0}; + PyObject* values[7] = {0,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 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 (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 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_search)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 7, 7, 1); __PYX_ERR(0, 204, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_name)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 7, 7, 2); __PYX_ERR(0, 204, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_id)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 7, 7, 3); __PYX_ERR(0, 204, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pos)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 7, 7, 4); __PYX_ERR(0, 204, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_property)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 7, 7, 5); __PYX_ERR(0, 204, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_logic)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 7, 7, 6); __PYX_ERR(0, 204, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "edit") < 0)) __PYX_ERR(0, 204, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 7) { + 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); + values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + } + __pyx_v_self = values[0]; + __pyx_v_search = values[1]; + __pyx_v_n_name = values[2]; + __pyx_v_n_id = values[3]; + __pyx_v_n_pos = values[4]; + __pyx_v_n_property = values[5]; + __pyx_v_n_logic = values[6]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("edit", 1, 7, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 204, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.c_entities.edit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_10c_entities_6edit(__pyx_self, __pyx_v_self, __pyx_v_search, __pyx_v_n_name, __pyx_v_n_id, __pyx_v_n_pos, __pyx_v_n_property, __pyx_v_n_logic); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_10c_entities_6edit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_pos, PyObject *__pyx_v_n_property, PyObject *__pyx_v_n_logic) { + Py_ssize_t __pyx_v_position; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + __Pyx_RefNannySetupContext("edit", 0); + + /* "analysis.py":205 + * + * def edit(self, search, n_name, n_id, n_pos, n_property, n_logic): + * position = 0 # <<<<<<<<<<<<<< + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + */ + __pyx_v_position = 0; + + /* "analysis.py":206 + * def edit(self, search, n_name, n_id, n_pos, n_property, n_logic): + * position = 0 + * for i in range(0, len(self.c_ids), 1): # <<<<<<<<<<<<<< + * if self.c_ids[i] == search: + * position = i + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 206, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "analysis.py":207 + * position = 0 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * if n_name != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_v_search, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_6) { + + /* "analysis.py":208 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + * position = i # <<<<<<<<<<<<<< + * if n_name != "null": + * self.c_names[position] = n_name + */ + __pyx_v_position = __pyx_v_i; + + /* "analysis.py":207 + * position = 0 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * if n_name != "null": + */ + } + } + + /* "analysis.py":209 + * if self.c_ids[i] == search: + * position = i + * if n_name != "null": # <<<<<<<<<<<<<< + * self.c_names[position] = n_name + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_name, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 209, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":210 + * position = i + * if n_name != "null": + * self.c_names[position] = n_name # <<<<<<<<<<<<<< + * + * if n_id != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_name, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":209 + * if self.c_ids[i] == search: + * position = i + * if n_name != "null": # <<<<<<<<<<<<<< + * self.c_names[position] = n_name + * + */ + } + + /* "analysis.py":212 + * self.c_names[position] = n_name + * + * if n_id != "null": # <<<<<<<<<<<<<< + * self.c_ids[position] = n_id + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_id, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 212, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":213 + * + * if n_id != "null": + * self.c_ids[position] = n_id # <<<<<<<<<<<<<< + * + * if n_pos != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_id, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 213, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":212 + * self.c_names[position] = n_name + * + * if n_id != "null": # <<<<<<<<<<<<<< + * self.c_ids[position] = n_id + * + */ + } + + /* "analysis.py":215 + * self.c_ids[position] = n_id + * + * if n_pos != "null": # <<<<<<<<<<<<<< + * self.c_pos[position] = n_pos + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_pos, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 215, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":216 + * + * if n_pos != "null": + * self.c_pos[position] = n_pos # <<<<<<<<<<<<<< + * + * if n_property != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_pos, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":215 + * self.c_ids[position] = n_id + * + * if n_pos != "null": # <<<<<<<<<<<<<< + * self.c_pos[position] = n_pos + * + */ + } + + /* "analysis.py":218 + * self.c_pos[position] = n_pos + * + * if n_property != "null": # <<<<<<<<<<<<<< + * self.c_properties[position] = n_property + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_property, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 218, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":219 + * + * if n_property != "null": + * self.c_properties[position] = n_property # <<<<<<<<<<<<<< + * + * if n_logic != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_properties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_property, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":218 + * self.c_pos[position] = n_pos + * + * if n_property != "null": # <<<<<<<<<<<<<< + * self.c_properties[position] = n_property + * + */ + } + + /* "analysis.py":221 + * self.c_properties[position] = n_property + * + * if n_logic != "null": # <<<<<<<<<<<<<< + * self.c_logic[position] = n_logic + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_logic, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 221, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":222 + * + * if n_logic != "null": + * self.c_logic[position] = n_logic # <<<<<<<<<<<<<< + * + * return None + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_logic); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_logic, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":221 + * self.c_properties[position] = n_property + * + * if n_logic != "null": # <<<<<<<<<<<<<< + * self.c_logic[position] = n_logic + * + */ + } + + /* "analysis.py":224 + * self.c_logic[position] = n_logic + * + * return None # <<<<<<<<<<<<<< + * + * def search(self, search): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "analysis.py":204 + * return None + * + * def edit(self, search, n_name, n_id, n_pos, n_property, n_logic): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("analysis.c_entities.edit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":226 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_10c_entities_9search(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_10c_entities_9search = {"search", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_10c_entities_9search, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_10c_entities_9search(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_search = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("search (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_search,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_self)) != 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_search)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("search", 1, 2, 2, 1); __PYX_ERR(0, 226, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "search") < 0)) __PYX_ERR(0, 226, __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_self = values[0]; + __pyx_v_search = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("search", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 226, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.c_entities.search", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_10c_entities_8search(__pyx_self, __pyx_v_self, __pyx_v_search); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_10c_entities_8search(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search) { + Py_ssize_t __pyx_v_position; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + __Pyx_RefNannySetupContext("search", 0); + + /* "analysis.py":227 + * + * def search(self, search): + * position = 0 # <<<<<<<<<<<<<< + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + */ + __pyx_v_position = 0; + + /* "analysis.py":228 + * def search(self, search): + * position = 0 + * for i in range(0, len(self.c_ids), 1): # <<<<<<<<<<<<<< + * if self.c_ids[i] == search: + * position = i + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "analysis.py":229 + * position = 0 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_v_search, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_6) { + + /* "analysis.py":230 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + * position = i # <<<<<<<<<<<<<< + * + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_properties[position], self.c_logic[position]] + */ + __pyx_v_position = __pyx_v_i; + + /* "analysis.py":229 + * position = 0 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * + */ + } + } + + /* "analysis.py":232 + * position = i + * + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_properties[position], self.c_logic[position]] # <<<<<<<<<<<<<< + * + * def regurgitate(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_properties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_logic); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyList_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_5); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_7); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_8); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_t_8); + __Pyx_GIVEREF(__pyx_t_9); + PyList_SET_ITEM(__pyx_t_1, 3, __pyx_t_9); + __Pyx_GIVEREF(__pyx_t_10); + PyList_SET_ITEM(__pyx_t_1, 4, __pyx_t_10); + __pyx_t_5 = 0; + __pyx_t_7 = 0; + __pyx_t_8 = 0; + __pyx_t_9 = 0; + __pyx_t_10 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "analysis.py":226 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("analysis.c_entities.search", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":234 + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_properties[position], self.c_logic[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_10c_entities_11regurgitate(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_10c_entities_11regurgitate = {"regurgitate", (PyCFunction)__pyx_pw_8analysis_10c_entities_11regurgitate, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_10c_entities_11regurgitate(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("regurgitate (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_10c_entities_10regurgitate(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_10c_entities_10regurgitate(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + 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; + __Pyx_RefNannySetupContext("regurgitate", 0); + + /* "analysis.py":235 + * + * def regurgitate(self): + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_properties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_logic); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyList_New(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_1); + PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyList_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyList_SET_ITEM(__pyx_t_6, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_6, 3, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyList_SET_ITEM(__pyx_t_6, 4, __pyx_t_5); + __pyx_t_1 = 0; + __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; + + /* "analysis.py":234 + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_properties[position], self.c_logic[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] + * + */ + + /* 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("analysis.c_entities.regurgitate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":246 + * c_effects = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("nc_entities (non-controlable entities) has attributes names, ids, positions, properties, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of positions, 2d array of properties, and 2d array of effects.") + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_11nc_entities_1debug(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_11nc_entities_1debug = {"debug", (PyCFunction)__pyx_pw_8analysis_11nc_entities_1debug, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_11nc_entities_1debug(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("debug (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_11nc_entities_debug(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_11nc_entities_debug(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + 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; + __Pyx_RefNannySetupContext("debug", 0); + + /* "analysis.py":247 + * + * def debug(self): + * print("nc_entities (non-controlable entities) has attributes names, ids, positions, properties, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of positions, 2d array of properties, and 2d array of effects.") # <<<<<<<<<<<<<< + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] + * + */ + if (__Pyx_PrintOne(0, __pyx_kp_s_nc_entities_non_controlable_enti) < 0) __PYX_ERR(0, 247, __pyx_L1_error) + + /* "analysis.py":248 + * def debug(self): + * print("nc_entities (non-controlable entities) has attributes names, ids, positions, properties, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of positions, 2d array of properties, and 2d array of effects.") + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] # <<<<<<<<<<<<<< + * + * def __init__(self, names, ids, pos, properties, effects): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_properties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyList_New(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_1); + PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyList_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyList_SET_ITEM(__pyx_t_6, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_6, 3, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyList_SET_ITEM(__pyx_t_6, 4, __pyx_t_5); + __pyx_t_1 = 0; + __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; + + /* "analysis.py":246 + * c_effects = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("nc_entities (non-controlable entities) has attributes names, ids, positions, properties, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of positions, 2d array of properties, and 2d array of effects.") + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] + */ + + /* 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("analysis.nc_entities.debug", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":250 + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] + * + * def __init__(self, names, ids, pos, properties, effects): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_11nc_entities_3__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_11nc_entities_3__init__ = {"__init__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_11nc_entities_3__init__, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_11nc_entities_3__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_names = 0; + PyObject *__pyx_v_ids = 0; + PyObject *__pyx_v_pos = 0; + PyObject *__pyx_v_properties = 0; + PyObject *__pyx_v_effects = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_names,&__pyx_n_s_ids,&__pyx_n_s_pos,&__pyx_n_s_properties,&__pyx_n_s_effects,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_self)) != 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_names)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 1); __PYX_ERR(0, 250, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ids)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 2); __PYX_ERR(0, 250, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pos)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 3); __PYX_ERR(0, 250, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_properties)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 4); __PYX_ERR(0, 250, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_effects)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, 5); __PYX_ERR(0, 250, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 250, __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_self = values[0]; + __pyx_v_names = values[1]; + __pyx_v_ids = values[2]; + __pyx_v_pos = values[3]; + __pyx_v_properties = values[4]; + __pyx_v_effects = values[5]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 250, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.nc_entities.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_11nc_entities_2__init__(__pyx_self, __pyx_v_self, __pyx_v_names, __pyx_v_ids, __pyx_v_pos, __pyx_v_properties, __pyx_v_effects); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_11nc_entities_2__init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_names, PyObject *__pyx_v_ids, PyObject *__pyx_v_pos, PyObject *__pyx_v_properties, PyObject *__pyx_v_effects) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__", 0); + + /* "analysis.py":251 + * + * def __init__(self, names, ids, pos, properties, effects): + * self.c_names = names # <<<<<<<<<<<<<< + * self.c_ids = ids + * self.c_pos = pos + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_names, __pyx_v_names) < 0) __PYX_ERR(0, 251, __pyx_L1_error) + + /* "analysis.py":252 + * def __init__(self, names, ids, pos, properties, effects): + * self.c_names = names + * self.c_ids = ids # <<<<<<<<<<<<<< + * self.c_pos = pos + * self.c_properties = properties + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_ids, __pyx_v_ids) < 0) __PYX_ERR(0, 252, __pyx_L1_error) + + /* "analysis.py":253 + * self.c_names = names + * self.c_ids = ids + * self.c_pos = pos # <<<<<<<<<<<<<< + * self.c_properties = properties + * self.c_effects = effects + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_pos, __pyx_v_pos) < 0) __PYX_ERR(0, 253, __pyx_L1_error) + + /* "analysis.py":254 + * self.c_ids = ids + * self.c_pos = pos + * self.c_properties = properties # <<<<<<<<<<<<<< + * self.c_effects = effects + * return None + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_properties, __pyx_v_properties) < 0) __PYX_ERR(0, 254, __pyx_L1_error) + + /* "analysis.py":255 + * self.c_pos = pos + * self.c_properties = properties + * self.c_effects = effects # <<<<<<<<<<<<<< + * return None + * + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_effects, __pyx_v_effects) < 0) __PYX_ERR(0, 255, __pyx_L1_error) + + /* "analysis.py":256 + * self.c_properties = properties + * self.c_effects = effects + * return None # <<<<<<<<<<<<<< + * + * def append(self, n_name, n_id, n_pos, n_property, n_effect): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "analysis.py":250 + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] + * + * def __init__(self, names, ids, pos, properties, effects): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("analysis.nc_entities.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":258 + * return None + * + * def append(self, n_name, n_id, n_pos, n_property, n_effect): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_11nc_entities_5append(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_11nc_entities_5append = {"append", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_11nc_entities_5append, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_11nc_entities_5append(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_n_name = 0; + PyObject *__pyx_v_n_id = 0; + PyObject *__pyx_v_n_pos = 0; + PyObject *__pyx_v_n_property = 0; + PyObject *__pyx_v_n_effect = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("append (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_n_name,&__pyx_n_s_n_id,&__pyx_n_s_n_pos,&__pyx_n_s_n_property,&__pyx_n_s_n_effect,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_self)) != 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_name)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 6, 6, 1); __PYX_ERR(0, 258, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_id)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 6, 6, 2); __PYX_ERR(0, 258, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pos)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 6, 6, 3); __PYX_ERR(0, 258, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_property)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 6, 6, 4); __PYX_ERR(0, 258, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_effect)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 6, 6, 5); __PYX_ERR(0, 258, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "append") < 0)) __PYX_ERR(0, 258, __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_self = values[0]; + __pyx_v_n_name = values[1]; + __pyx_v_n_id = values[2]; + __pyx_v_n_pos = values[3]; + __pyx_v_n_property = values[4]; + __pyx_v_n_effect = values[5]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("append", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 258, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.nc_entities.append", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_11nc_entities_4append(__pyx_self, __pyx_v_self, __pyx_v_n_name, __pyx_v_n_id, __pyx_v_n_pos, __pyx_v_n_property, __pyx_v_n_effect); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_11nc_entities_4append(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_pos, PyObject *__pyx_v_n_property, PyObject *__pyx_v_n_effect) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + __Pyx_RefNannySetupContext("append", 0); + + /* "analysis.py":259 + * + * def append(self, n_name, n_id, n_pos, n_property, n_effect): + * self.c_names.append(n_name) # <<<<<<<<<<<<<< + * self.c_ids.append(n_id) + * self.c_pos.append(n_pos) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_name); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 259, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":260 + * def append(self, n_name, n_id, n_pos, n_property, n_effect): + * self.c_names.append(n_name) + * self.c_ids.append(n_id) # <<<<<<<<<<<<<< + * self.c_pos.append(n_pos) + * self.c_properties.append(n_property) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_id); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":261 + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + * self.c_pos.append(n_pos) # <<<<<<<<<<<<<< + * self.c_properties.append(n_property) + * self.c_effects.append(n_effect) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_pos); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":262 + * self.c_ids.append(n_id) + * self.c_pos.append(n_pos) + * self.c_properties.append(n_property) # <<<<<<<<<<<<<< + * self.c_effects.append(n_effect) + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_properties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 262, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_property); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 262, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":263 + * self.c_pos.append(n_pos) + * self.c_properties.append(n_property) + * self.c_effects.append(n_effect) # <<<<<<<<<<<<<< + * + * return None + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_effect); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 263, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":265 + * self.c_effects.append(n_effect) + * + * return None # <<<<<<<<<<<<<< + * + * def edit(self, search, n_name, n_id, n_pos, n_property, n_effect): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "analysis.py":258 + * return None + * + * def append(self, n_name, n_id, n_pos, n_property, n_effect): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("analysis.nc_entities.append", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":267 + * return None + * + * def edit(self, search, n_name, n_id, n_pos, n_property, n_effect): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_11nc_entities_7edit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_11nc_entities_7edit = {"edit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_11nc_entities_7edit, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_11nc_entities_7edit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_search = 0; + PyObject *__pyx_v_n_name = 0; + PyObject *__pyx_v_n_id = 0; + PyObject *__pyx_v_n_pos = 0; + PyObject *__pyx_v_n_property = 0; + PyObject *__pyx_v_n_effect = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("edit (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_search,&__pyx_n_s_n_name,&__pyx_n_s_n_id,&__pyx_n_s_n_pos,&__pyx_n_s_n_property,&__pyx_n_s_n_effect,0}; + PyObject* values[7] = {0,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 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 (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 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_search)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 7, 7, 1); __PYX_ERR(0, 267, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_name)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 7, 7, 2); __PYX_ERR(0, 267, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_id)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 7, 7, 3); __PYX_ERR(0, 267, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pos)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 7, 7, 4); __PYX_ERR(0, 267, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_property)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 7, 7, 5); __PYX_ERR(0, 267, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_effect)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 7, 7, 6); __PYX_ERR(0, 267, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "edit") < 0)) __PYX_ERR(0, 267, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 7) { + 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); + values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + } + __pyx_v_self = values[0]; + __pyx_v_search = values[1]; + __pyx_v_n_name = values[2]; + __pyx_v_n_id = values[3]; + __pyx_v_n_pos = values[4]; + __pyx_v_n_property = values[5]; + __pyx_v_n_effect = values[6]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("edit", 1, 7, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 267, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.nc_entities.edit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_11nc_entities_6edit(__pyx_self, __pyx_v_self, __pyx_v_search, __pyx_v_n_name, __pyx_v_n_id, __pyx_v_n_pos, __pyx_v_n_property, __pyx_v_n_effect); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_11nc_entities_6edit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_pos, PyObject *__pyx_v_n_property, PyObject *__pyx_v_n_effect) { + Py_ssize_t __pyx_v_position; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + __Pyx_RefNannySetupContext("edit", 0); + + /* "analysis.py":268 + * + * def edit(self, search, n_name, n_id, n_pos, n_property, n_effect): + * position = 0 # <<<<<<<<<<<<<< + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + */ + __pyx_v_position = 0; + + /* "analysis.py":269 + * def edit(self, search, n_name, n_id, n_pos, n_property, n_effect): + * position = 0 + * for i in range(0, len(self.c_ids), 1): # <<<<<<<<<<<<<< + * if self.c_ids[i] == search: + * position = i + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 269, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "analysis.py":270 + * position = 0 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * if n_name != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_v_search, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_6) { + + /* "analysis.py":271 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + * position = i # <<<<<<<<<<<<<< + * if n_name != "null": + * self.c_names[position] = n_name + */ + __pyx_v_position = __pyx_v_i; + + /* "analysis.py":270 + * position = 0 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * if n_name != "null": + */ + } + } + + /* "analysis.py":272 + * if self.c_ids[i] == search: + * position = i + * if n_name != "null": # <<<<<<<<<<<<<< + * self.c_names[position] = n_name + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_name, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 272, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":273 + * position = i + * if n_name != "null": + * self.c_names[position] = n_name # <<<<<<<<<<<<<< + * + * if n_id != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_name, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":272 + * if self.c_ids[i] == search: + * position = i + * if n_name != "null": # <<<<<<<<<<<<<< + * self.c_names[position] = n_name + * + */ + } + + /* "analysis.py":275 + * self.c_names[position] = n_name + * + * if n_id != "null": # <<<<<<<<<<<<<< + * self.c_ids[position] = n_id + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_id, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 275, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":276 + * + * if n_id != "null": + * self.c_ids[position] = n_id # <<<<<<<<<<<<<< + * + * if n_pos != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_id, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":275 + * self.c_names[position] = n_name + * + * if n_id != "null": # <<<<<<<<<<<<<< + * self.c_ids[position] = n_id + * + */ + } + + /* "analysis.py":278 + * self.c_ids[position] = n_id + * + * if n_pos != "null": # <<<<<<<<<<<<<< + * self.c_pos[position] = n_pos + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_pos, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 278, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":279 + * + * if n_pos != "null": + * self.c_pos[position] = n_pos # <<<<<<<<<<<<<< + * + * if n_property != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_pos, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 279, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":278 + * self.c_ids[position] = n_id + * + * if n_pos != "null": # <<<<<<<<<<<<<< + * self.c_pos[position] = n_pos + * + */ + } + + /* "analysis.py":281 + * self.c_pos[position] = n_pos + * + * if n_property != "null": # <<<<<<<<<<<<<< + * self.c_properties[position] = n_property + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_property, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 281, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":282 + * + * if n_property != "null": + * self.c_properties[position] = n_property # <<<<<<<<<<<<<< + * + * if n_effect != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_properties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_property, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 282, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":281 + * self.c_pos[position] = n_pos + * + * if n_property != "null": # <<<<<<<<<<<<<< + * self.c_properties[position] = n_property + * + */ + } + + /* "analysis.py":284 + * self.c_properties[position] = n_property + * + * if n_effect != "null": # <<<<<<<<<<<<<< + * self.c_effects[position] = n_effect + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_effect, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 284, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":285 + * + * if n_effect != "null": + * self.c_effects[position] = n_effect # <<<<<<<<<<<<<< + * + * return None + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_effect, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":284 + * self.c_properties[position] = n_property + * + * if n_effect != "null": # <<<<<<<<<<<<<< + * self.c_effects[position] = n_effect + * + */ + } + + /* "analysis.py":287 + * self.c_effects[position] = n_effect + * + * return None # <<<<<<<<<<<<<< + * + * def search(self, search): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "analysis.py":267 + * return None + * + * def edit(self, search, n_name, n_id, n_pos, n_property, n_effect): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("analysis.nc_entities.edit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":289 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_11nc_entities_9search(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_11nc_entities_9search = {"search", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_11nc_entities_9search, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_11nc_entities_9search(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_search = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("search (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_search,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_self)) != 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_search)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("search", 1, 2, 2, 1); __PYX_ERR(0, 289, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "search") < 0)) __PYX_ERR(0, 289, __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_self = values[0]; + __pyx_v_search = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("search", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 289, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.nc_entities.search", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_11nc_entities_8search(__pyx_self, __pyx_v_self, __pyx_v_search); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_11nc_entities_8search(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search) { + Py_ssize_t __pyx_v_position; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + __Pyx_RefNannySetupContext("search", 0); + + /* "analysis.py":290 + * + * def search(self, search): + * position = 0 # <<<<<<<<<<<<<< + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + */ + __pyx_v_position = 0; + + /* "analysis.py":291 + * def search(self, search): + * position = 0 + * for i in range(0, len(self.c_ids), 1): # <<<<<<<<<<<<<< + * if self.c_ids[i] == search: + * position = i + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 291, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "analysis.py":292 + * position = 0 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_v_search, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 292, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 292, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_6) { + + /* "analysis.py":293 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + * position = i # <<<<<<<<<<<<<< + * + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_properties[position], self.c_effects[position]] + */ + __pyx_v_position = __pyx_v_i; + + /* "analysis.py":292 + * position = 0 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * + */ + } + } + + /* "analysis.py":295 + * position = i + * + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_properties[position], self.c_effects[position]] # <<<<<<<<<<<<<< + * + * def regurgitate(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_properties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyList_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_5); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_7); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_8); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_t_8); + __Pyx_GIVEREF(__pyx_t_9); + PyList_SET_ITEM(__pyx_t_1, 3, __pyx_t_9); + __Pyx_GIVEREF(__pyx_t_10); + PyList_SET_ITEM(__pyx_t_1, 4, __pyx_t_10); + __pyx_t_5 = 0; + __pyx_t_7 = 0; + __pyx_t_8 = 0; + __pyx_t_9 = 0; + __pyx_t_10 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "analysis.py":289 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("analysis.nc_entities.search", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":297 + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_properties[position], self.c_effects[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_11nc_entities_11regurgitate(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_11nc_entities_11regurgitate = {"regurgitate", (PyCFunction)__pyx_pw_8analysis_11nc_entities_11regurgitate, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_11nc_entities_11regurgitate(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("regurgitate (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_11nc_entities_10regurgitate(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_11nc_entities_10regurgitate(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + 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; + __Pyx_RefNannySetupContext("regurgitate", 0); + + /* "analysis.py":299 + * def regurgitate(self): + * + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_properties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyList_New(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_1); + PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyList_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyList_SET_ITEM(__pyx_t_6, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_6, 3, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyList_SET_ITEM(__pyx_t_6, 4, __pyx_t_5); + __pyx_t_1 = 0; + __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; + + /* "analysis.py":297 + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_properties[position], self.c_effects[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] + */ + + /* 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("analysis.nc_entities.regurgitate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":309 + * c_effects = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("obstacles has atributes names, ids, positions, perimeters, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 3d array of perimeters, 2d array of effects.") + * return [self.c_names, self.c_ids, self.c_perim, self.c_effects] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_9obstacles_1debug(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_9obstacles_1debug = {"debug", (PyCFunction)__pyx_pw_8analysis_9obstacles_1debug, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_9obstacles_1debug(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("debug (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_9obstacles_debug(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_9obstacles_debug(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + 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; + __Pyx_RefNannySetupContext("debug", 0); + + /* "analysis.py":310 + * + * def debug(self): + * print("obstacles has atributes names, ids, positions, perimeters, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 3d array of perimeters, 2d array of effects.") # <<<<<<<<<<<<<< + * return [self.c_names, self.c_ids, self.c_perim, self.c_effects] + * + */ + if (__Pyx_PrintOne(0, __pyx_kp_s_obstacles_has_atributes_names_id) < 0) __PYX_ERR(0, 310, __pyx_L1_error) + + /* "analysis.py":311 + * def debug(self): + * print("obstacles has atributes names, ids, positions, perimeters, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 3d array of perimeters, 2d array of effects.") + * return [self.c_names, self.c_ids, self.c_perim, self.c_effects] # <<<<<<<<<<<<<< + * + * def __init__(self, names, ids, perims, effects): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_perim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyList_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyList_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyList_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyList_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "analysis.py":309 + * c_effects = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("obstacles has atributes names, ids, positions, perimeters, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 3d array of perimeters, 2d array of effects.") + * return [self.c_names, self.c_ids, self.c_perim, self.c_effects] + */ + + /* 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("analysis.obstacles.debug", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":313 + * return [self.c_names, self.c_ids, self.c_perim, self.c_effects] + * + * def __init__(self, names, ids, perims, effects): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_9obstacles_3__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_9obstacles_3__init__ = {"__init__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_9obstacles_3__init__, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_9obstacles_3__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_names = 0; + PyObject *__pyx_v_ids = 0; + PyObject *__pyx_v_perims = 0; + PyObject *__pyx_v_effects = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_names,&__pyx_n_s_ids,&__pyx_n_s_perims,&__pyx_n_s_effects,0}; + PyObject* values[5] = {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 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_self)) != 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_names)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 1); __PYX_ERR(0, 313, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ids)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 2); __PYX_ERR(0, 313, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_perims)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 3); __PYX_ERR(0, 313, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_effects)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 4); __PYX_ERR(0, 313, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 313, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { + 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); + } + __pyx_v_self = values[0]; + __pyx_v_names = values[1]; + __pyx_v_ids = values[2]; + __pyx_v_perims = values[3]; + __pyx_v_effects = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 313, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.obstacles.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_9obstacles_2__init__(__pyx_self, __pyx_v_self, __pyx_v_names, __pyx_v_ids, __pyx_v_perims, __pyx_v_effects); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_9obstacles_2__init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_names, PyObject *__pyx_v_ids, PyObject *__pyx_v_perims, PyObject *__pyx_v_effects) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__", 0); + + /* "analysis.py":314 + * + * def __init__(self, names, ids, perims, effects): + * self.c_names = names # <<<<<<<<<<<<<< + * self.c_ids = ids + * self.c_perim = perims + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_names, __pyx_v_names) < 0) __PYX_ERR(0, 314, __pyx_L1_error) + + /* "analysis.py":315 + * def __init__(self, names, ids, perims, effects): + * self.c_names = names + * self.c_ids = ids # <<<<<<<<<<<<<< + * self.c_perim = perims + * self.c_effects = effects + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_ids, __pyx_v_ids) < 0) __PYX_ERR(0, 315, __pyx_L1_error) + + /* "analysis.py":316 + * self.c_names = names + * self.c_ids = ids + * self.c_perim = perims # <<<<<<<<<<<<<< + * self.c_effects = effects + * return None + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_perim, __pyx_v_perims) < 0) __PYX_ERR(0, 316, __pyx_L1_error) + + /* "analysis.py":317 + * self.c_ids = ids + * self.c_perim = perims + * self.c_effects = effects # <<<<<<<<<<<<<< + * return None + * + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_effects, __pyx_v_effects) < 0) __PYX_ERR(0, 317, __pyx_L1_error) + + /* "analysis.py":318 + * self.c_perim = perims + * self.c_effects = effects + * return None # <<<<<<<<<<<<<< + * + * def append(self, n_name, n_id, n_perim, n_effect): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "analysis.py":313 + * return [self.c_names, self.c_ids, self.c_perim, self.c_effects] + * + * def __init__(self, names, ids, perims, effects): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("analysis.obstacles.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":320 + * return None + * + * def append(self, n_name, n_id, n_perim, n_effect): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_9obstacles_5append(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_9obstacles_5append = {"append", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_9obstacles_5append, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_9obstacles_5append(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_n_name = 0; + PyObject *__pyx_v_n_id = 0; + PyObject *__pyx_v_n_perim = 0; + PyObject *__pyx_v_n_effect = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("append (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_n_name,&__pyx_n_s_n_id,&__pyx_n_s_n_perim,&__pyx_n_s_n_effect,0}; + PyObject* values[5] = {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 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_self)) != 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_name)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 5, 5, 1); __PYX_ERR(0, 320, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_id)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 5, 5, 2); __PYX_ERR(0, 320, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_perim)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 5, 5, 3); __PYX_ERR(0, 320, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_effect)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 5, 5, 4); __PYX_ERR(0, 320, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "append") < 0)) __PYX_ERR(0, 320, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { + 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); + } + __pyx_v_self = values[0]; + __pyx_v_n_name = values[1]; + __pyx_v_n_id = values[2]; + __pyx_v_n_perim = values[3]; + __pyx_v_n_effect = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("append", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 320, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.obstacles.append", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_9obstacles_4append(__pyx_self, __pyx_v_self, __pyx_v_n_name, __pyx_v_n_id, __pyx_v_n_perim, __pyx_v_n_effect); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_9obstacles_4append(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_perim, PyObject *__pyx_v_n_effect) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + __Pyx_RefNannySetupContext("append", 0); + + /* "analysis.py":321 + * + * def append(self, n_name, n_id, n_perim, n_effect): + * self.c_names.append(n_name) # <<<<<<<<<<<<<< + * self.c_ids.append(n_id) + * self.c_perim.append(n_perim) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 321, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_name); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 321, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":322 + * def append(self, n_name, n_id, n_perim, n_effect): + * self.c_names.append(n_name) + * self.c_ids.append(n_id) # <<<<<<<<<<<<<< + * self.c_perim.append(n_perim) + * self.c_effects.append(n_effect) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_id); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":323 + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + * self.c_perim.append(n_perim) # <<<<<<<<<<<<<< + * self.c_effects.append(n_effect) + * return None + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_perim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_perim); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":324 + * self.c_ids.append(n_id) + * self.c_perim.append(n_perim) + * self.c_effects.append(n_effect) # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_effect); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 324, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":325 + * self.c_perim.append(n_perim) + * self.c_effects.append(n_effect) + * return None # <<<<<<<<<<<<<< + * + * def edit(self, search, n_name, n_id, n_perim, n_effect): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "analysis.py":320 + * return None + * + * def append(self, n_name, n_id, n_perim, n_effect): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("analysis.obstacles.append", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":327 + * return None + * + * def edit(self, search, n_name, n_id, n_perim, n_effect): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_9obstacles_7edit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_9obstacles_7edit = {"edit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_9obstacles_7edit, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_9obstacles_7edit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_search = 0; + PyObject *__pyx_v_n_name = 0; + PyObject *__pyx_v_n_id = 0; + PyObject *__pyx_v_n_perim = 0; + PyObject *__pyx_v_n_effect = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("edit (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_search,&__pyx_n_s_n_name,&__pyx_n_s_n_id,&__pyx_n_s_n_perim,&__pyx_n_s_n_effect,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_self)) != 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_search)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 6, 6, 1); __PYX_ERR(0, 327, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_name)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 6, 6, 2); __PYX_ERR(0, 327, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_id)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 6, 6, 3); __PYX_ERR(0, 327, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_perim)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 6, 6, 4); __PYX_ERR(0, 327, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_effect)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 6, 6, 5); __PYX_ERR(0, 327, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "edit") < 0)) __PYX_ERR(0, 327, __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_self = values[0]; + __pyx_v_search = values[1]; + __pyx_v_n_name = values[2]; + __pyx_v_n_id = values[3]; + __pyx_v_n_perim = values[4]; + __pyx_v_n_effect = values[5]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("edit", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 327, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.obstacles.edit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_9obstacles_6edit(__pyx_self, __pyx_v_self, __pyx_v_search, __pyx_v_n_name, __pyx_v_n_id, __pyx_v_n_perim, __pyx_v_n_effect); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_9obstacles_6edit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_perim, PyObject *__pyx_v_n_effect) { + Py_ssize_t __pyx_v_position; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + __Pyx_RefNannySetupContext("edit", 0); + + /* "analysis.py":328 + * + * def edit(self, search, n_name, n_id, n_perim, n_effect): + * position = 0 # <<<<<<<<<<<<<< + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + */ + __pyx_v_position = 0; + + /* "analysis.py":329 + * def edit(self, search, n_name, n_id, n_perim, n_effect): + * position = 0 + * for i in range(0, len(self.c_ids), 1): # <<<<<<<<<<<<<< + * if self.c_ids[i] == search: + * position = i + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 329, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 329, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "analysis.py":330 + * position = 0 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 330, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 330, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_v_search, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 330, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 330, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_6) { + + /* "analysis.py":331 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + * position = i # <<<<<<<<<<<<<< + * + * if n_name != "null": + */ + __pyx_v_position = __pyx_v_i; + + /* "analysis.py":330 + * position = 0 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * + */ + } + } + + /* "analysis.py":333 + * position = i + * + * if n_name != "null": # <<<<<<<<<<<<<< + * self.c_names[position] = n_name + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_name, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 333, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":334 + * + * if n_name != "null": + * self.c_names[position] = n_name # <<<<<<<<<<<<<< + * + * if n_id != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 334, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_name, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 334, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":333 + * position = i + * + * if n_name != "null": # <<<<<<<<<<<<<< + * self.c_names[position] = n_name + * + */ + } + + /* "analysis.py":336 + * self.c_names[position] = n_name + * + * if n_id != "null": # <<<<<<<<<<<<<< + * self.c_ids[position] = n_id + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_id, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 336, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":337 + * + * if n_id != "null": + * self.c_ids[position] = n_id # <<<<<<<<<<<<<< + * + * if n_perim != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_id, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 337, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":336 + * self.c_names[position] = n_name + * + * if n_id != "null": # <<<<<<<<<<<<<< + * self.c_ids[position] = n_id + * + */ + } + + /* "analysis.py":339 + * self.c_ids[position] = n_id + * + * if n_perim != "null": # <<<<<<<<<<<<<< + * self.c_perim[position] = n_perim + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_perim, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 339, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":340 + * + * if n_perim != "null": + * self.c_perim[position] = n_perim # <<<<<<<<<<<<<< + * + * if n_effect != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_perim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_perim, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":339 + * self.c_ids[position] = n_id + * + * if n_perim != "null": # <<<<<<<<<<<<<< + * self.c_perim[position] = n_perim + * + */ + } + + /* "analysis.py":342 + * self.c_perim[position] = n_perim + * + * if n_effect != "null": # <<<<<<<<<<<<<< + * self.c_effects[position] = n_effect + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_effect, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 342, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":343 + * + * if n_effect != "null": + * self.c_effects[position] = n_effect # <<<<<<<<<<<<<< + * + * return None + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_effect, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 343, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":342 + * self.c_perim[position] = n_perim + * + * if n_effect != "null": # <<<<<<<<<<<<<< + * self.c_effects[position] = n_effect + * + */ + } + + /* "analysis.py":345 + * self.c_effects[position] = n_effect + * + * return None # <<<<<<<<<<<<<< + * + * def search(self, search): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "analysis.py":327 + * return None + * + * def edit(self, search, n_name, n_id, n_perim, n_effect): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("analysis.obstacles.edit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":347 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_9obstacles_9search(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_9obstacles_9search = {"search", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_9obstacles_9search, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_9obstacles_9search(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_search = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("search (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_search,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_self)) != 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_search)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("search", 1, 2, 2, 1); __PYX_ERR(0, 347, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "search") < 0)) __PYX_ERR(0, 347, __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_self = values[0]; + __pyx_v_search = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("search", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 347, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.obstacles.search", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_9obstacles_8search(__pyx_self, __pyx_v_self, __pyx_v_search); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_9obstacles_8search(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search) { + Py_ssize_t __pyx_v_position; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("search", 0); + + /* "analysis.py":348 + * + * def search(self, search): + * position = 0 # <<<<<<<<<<<<<< + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + */ + __pyx_v_position = 0; + + /* "analysis.py":349 + * def search(self, search): + * position = 0 + * for i in range(0, len(self.c_ids), 1): # <<<<<<<<<<<<<< + * if self.c_ids[i] == search: + * position = i + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "analysis.py":350 + * position = 0 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 350, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 350, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_v_search, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 350, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 350, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_6) { + + /* "analysis.py":351 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + * position = i # <<<<<<<<<<<<<< + * + * return [self.c_names[position], self.c_ids[position], self.c_perim[position], self.c_effects[position]] + */ + __pyx_v_position = __pyx_v_i; + + /* "analysis.py":350 + * position = 0 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * + */ + } + } + + /* "analysis.py":353 + * position = i + * + * return [self.c_names[position], self.c_ids[position], self.c_perim[position], self.c_effects[position]] # <<<<<<<<<<<<<< + * + * def regurgitate(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_perim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyList_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_5); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_7); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_8); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_t_8); + __Pyx_GIVEREF(__pyx_t_9); + PyList_SET_ITEM(__pyx_t_1, 3, __pyx_t_9); + __pyx_t_5 = 0; + __pyx_t_7 = 0; + __pyx_t_8 = 0; + __pyx_t_9 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "analysis.py":347 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("analysis.obstacles.search", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":355 + * return [self.c_names[position], self.c_ids[position], self.c_perim[position], self.c_effects[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * return[self.c_names, self.c_ids, self.c_perim, self.c_effects] + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_9obstacles_11regurgitate(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_9obstacles_11regurgitate = {"regurgitate", (PyCFunction)__pyx_pw_8analysis_9obstacles_11regurgitate, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_9obstacles_11regurgitate(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("regurgitate (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_9obstacles_10regurgitate(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_9obstacles_10regurgitate(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + 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; + __Pyx_RefNannySetupContext("regurgitate", 0); + + /* "analysis.py":356 + * + * def regurgitate(self): + * return[self.c_names, self.c_ids, self.c_perim, self.c_effects] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_perim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyList_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyList_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyList_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyList_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "analysis.py":355 + * return [self.c_names[position], self.c_ids[position], self.c_perim[position], self.c_effects[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * return[self.c_names, self.c_ids, self.c_perim, self.c_effects] + * + */ + + /* 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("analysis.obstacles.regurgitate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":366 + * c_effects = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("objectives has atributes names, ids, positions, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 1d array of effects.") + * return [self.c_names, self.c_ids, self.c_pos, self.c_effects] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_10objectives_1debug(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_10objectives_1debug = {"debug", (PyCFunction)__pyx_pw_8analysis_10objectives_1debug, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_10objectives_1debug(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("debug (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_10objectives_debug(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_10objectives_debug(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + 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; + __Pyx_RefNannySetupContext("debug", 0); + + /* "analysis.py":367 + * + * def debug(self): + * print("objectives has atributes names, ids, positions, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 1d array of effects.") # <<<<<<<<<<<<<< + * return [self.c_names, self.c_ids, self.c_pos, self.c_effects] + * + */ + if (__Pyx_PrintOne(0, __pyx_kp_s_objectives_has_atributes_names_i) < 0) __PYX_ERR(0, 367, __pyx_L1_error) + + /* "analysis.py":368 + * def debug(self): + * print("objectives has atributes names, ids, positions, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 1d array of effects.") + * return [self.c_names, self.c_ids, self.c_pos, self.c_effects] # <<<<<<<<<<<<<< + * + * def __init__(self, names, ids, pos, effects): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyList_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyList_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyList_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyList_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "analysis.py":366 + * c_effects = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("objectives has atributes names, ids, positions, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 1d array of effects.") + * return [self.c_names, self.c_ids, self.c_pos, self.c_effects] + */ + + /* 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("analysis.objectives.debug", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":370 + * return [self.c_names, self.c_ids, self.c_pos, self.c_effects] + * + * def __init__(self, names, ids, pos, effects): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_10objectives_3__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_10objectives_3__init__ = {"__init__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_10objectives_3__init__, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_10objectives_3__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_names = 0; + PyObject *__pyx_v_ids = 0; + PyObject *__pyx_v_pos = 0; + PyObject *__pyx_v_effects = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_names,&__pyx_n_s_ids,&__pyx_n_s_pos,&__pyx_n_s_effects,0}; + PyObject* values[5] = {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 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_self)) != 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_names)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 1); __PYX_ERR(0, 370, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ids)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 2); __PYX_ERR(0, 370, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pos)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 3); __PYX_ERR(0, 370, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_effects)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 4); __PYX_ERR(0, 370, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 370, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { + 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); + } + __pyx_v_self = values[0]; + __pyx_v_names = values[1]; + __pyx_v_ids = values[2]; + __pyx_v_pos = values[3]; + __pyx_v_effects = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 370, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.objectives.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_10objectives_2__init__(__pyx_self, __pyx_v_self, __pyx_v_names, __pyx_v_ids, __pyx_v_pos, __pyx_v_effects); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_10objectives_2__init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_names, PyObject *__pyx_v_ids, PyObject *__pyx_v_pos, PyObject *__pyx_v_effects) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__", 0); + + /* "analysis.py":371 + * + * def __init__(self, names, ids, pos, effects): + * self.c_names = names # <<<<<<<<<<<<<< + * self.c_ids = ids + * self.c_pos = pos + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_names, __pyx_v_names) < 0) __PYX_ERR(0, 371, __pyx_L1_error) + + /* "analysis.py":372 + * def __init__(self, names, ids, pos, effects): + * self.c_names = names + * self.c_ids = ids # <<<<<<<<<<<<<< + * self.c_pos = pos + * self.c_effects = effects + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_ids, __pyx_v_ids) < 0) __PYX_ERR(0, 372, __pyx_L1_error) + + /* "analysis.py":373 + * self.c_names = names + * self.c_ids = ids + * self.c_pos = pos # <<<<<<<<<<<<<< + * self.c_effects = effects + * return None + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_pos, __pyx_v_pos) < 0) __PYX_ERR(0, 373, __pyx_L1_error) + + /* "analysis.py":374 + * self.c_ids = ids + * self.c_pos = pos + * self.c_effects = effects # <<<<<<<<<<<<<< + * return None + * + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_c_effects, __pyx_v_effects) < 0) __PYX_ERR(0, 374, __pyx_L1_error) + + /* "analysis.py":375 + * self.c_pos = pos + * self.c_effects = effects + * return None # <<<<<<<<<<<<<< + * + * def append(self, n_name, n_id, n_pos, n_effect): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "analysis.py":370 + * return [self.c_names, self.c_ids, self.c_pos, self.c_effects] + * + * def __init__(self, names, ids, pos, effects): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("analysis.objectives.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":377 + * return None + * + * def append(self, n_name, n_id, n_pos, n_effect): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_10objectives_5append(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_10objectives_5append = {"append", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_10objectives_5append, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_10objectives_5append(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_n_name = 0; + PyObject *__pyx_v_n_id = 0; + PyObject *__pyx_v_n_pos = 0; + PyObject *__pyx_v_n_effect = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("append (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_n_name,&__pyx_n_s_n_id,&__pyx_n_s_n_pos,&__pyx_n_s_n_effect,0}; + PyObject* values[5] = {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 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_self)) != 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_name)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 5, 5, 1); __PYX_ERR(0, 377, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_id)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 5, 5, 2); __PYX_ERR(0, 377, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pos)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 5, 5, 3); __PYX_ERR(0, 377, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_effect)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("append", 1, 5, 5, 4); __PYX_ERR(0, 377, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "append") < 0)) __PYX_ERR(0, 377, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { + 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); + } + __pyx_v_self = values[0]; + __pyx_v_n_name = values[1]; + __pyx_v_n_id = values[2]; + __pyx_v_n_pos = values[3]; + __pyx_v_n_effect = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("append", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 377, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.objectives.append", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_10objectives_4append(__pyx_self, __pyx_v_self, __pyx_v_n_name, __pyx_v_n_id, __pyx_v_n_pos, __pyx_v_n_effect); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_10objectives_4append(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_pos, PyObject *__pyx_v_n_effect) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + __Pyx_RefNannySetupContext("append", 0); + + /* "analysis.py":378 + * + * def append(self, n_name, n_id, n_pos, n_effect): + * self.c_names.append(n_name) # <<<<<<<<<<<<<< + * self.c_ids.append(n_id) + * self.c_pos.append(n_pos) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_name); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 378, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":379 + * def append(self, n_name, n_id, n_pos, n_effect): + * self.c_names.append(n_name) + * self.c_ids.append(n_id) # <<<<<<<<<<<<<< + * self.c_pos.append(n_pos) + * self.c_effects.append(n_effect) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_id); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":380 + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + * self.c_pos.append(n_pos) # <<<<<<<<<<<<<< + * self.c_effects.append(n_effect) + * return None + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_pos); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":381 + * self.c_ids.append(n_id) + * self.c_pos.append(n_pos) + * self.c_effects.append(n_effect) # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_v_n_effect); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 381, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":382 + * self.c_pos.append(n_pos) + * self.c_effects.append(n_effect) + * return None # <<<<<<<<<<<<<< + * + * def edit(self, search, n_name, n_id, n_pos, n_effect): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "analysis.py":377 + * return None + * + * def append(self, n_name, n_id, n_pos, n_effect): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("analysis.objectives.append", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":384 + * return None + * + * def edit(self, search, n_name, n_id, n_pos, n_effect): # <<<<<<<<<<<<<< + * position = 0 + * print(self.c_ids) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_10objectives_7edit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_10objectives_7edit = {"edit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_10objectives_7edit, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_10objectives_7edit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_search = 0; + PyObject *__pyx_v_n_name = 0; + PyObject *__pyx_v_n_id = 0; + PyObject *__pyx_v_n_pos = 0; + PyObject *__pyx_v_n_effect = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("edit (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_search,&__pyx_n_s_n_name,&__pyx_n_s_n_id,&__pyx_n_s_n_pos,&__pyx_n_s_n_effect,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_self)) != 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_search)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 6, 6, 1); __PYX_ERR(0, 384, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_name)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 6, 6, 2); __PYX_ERR(0, 384, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_id)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 6, 6, 3); __PYX_ERR(0, 384, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pos)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 6, 6, 4); __PYX_ERR(0, 384, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_effect)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("edit", 1, 6, 6, 5); __PYX_ERR(0, 384, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "edit") < 0)) __PYX_ERR(0, 384, __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_self = values[0]; + __pyx_v_search = values[1]; + __pyx_v_n_name = values[2]; + __pyx_v_n_id = values[3]; + __pyx_v_n_pos = values[4]; + __pyx_v_n_effect = values[5]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("edit", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 384, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.objectives.edit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_10objectives_6edit(__pyx_self, __pyx_v_self, __pyx_v_search, __pyx_v_n_name, __pyx_v_n_id, __pyx_v_n_pos, __pyx_v_n_effect); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_10objectives_6edit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search, PyObject *__pyx_v_n_name, PyObject *__pyx_v_n_id, PyObject *__pyx_v_n_pos, PyObject *__pyx_v_n_effect) { + Py_ssize_t __pyx_v_position; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + __Pyx_RefNannySetupContext("edit", 0); + + /* "analysis.py":385 + * + * def edit(self, search, n_name, n_id, n_pos, n_effect): + * position = 0 # <<<<<<<<<<<<<< + * print(self.c_ids) + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_v_position = 0; + + /* "analysis.py":386 + * def edit(self, search, n_name, n_id, n_pos, n_effect): + * position = 0 + * print(self.c_ids) # <<<<<<<<<<<<<< + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_PrintOne(0, __pyx_t_1) < 0) __PYX_ERR(0, 386, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":387 + * position = 0 + * print(self.c_ids) + * for i in range(0, len(self.c_ids), 1): # <<<<<<<<<<<<<< + * if self.c_ids[i] == search: + * position = i + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 387, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "analysis.py":388 + * print(self.c_ids) + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_v_search, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 388, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 388, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_6) { + + /* "analysis.py":389 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + * position = i # <<<<<<<<<<<<<< + * + * if n_name != "null": + */ + __pyx_v_position = __pyx_v_i; + + /* "analysis.py":388 + * print(self.c_ids) + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * + */ + } + } + + /* "analysis.py":391 + * position = i + * + * if n_name != "null": # <<<<<<<<<<<<<< + * self.c_names[position] = n_name + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_name, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 391, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":392 + * + * if n_name != "null": + * self.c_names[position] = n_name # <<<<<<<<<<<<<< + * + * if n_id != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_name, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 392, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":391 + * position = i + * + * if n_name != "null": # <<<<<<<<<<<<<< + * self.c_names[position] = n_name + * + */ + } + + /* "analysis.py":394 + * self.c_names[position] = n_name + * + * if n_id != "null": # <<<<<<<<<<<<<< + * self.c_ids[position] = n_id + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_id, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 394, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":395 + * + * if n_id != "null": + * self.c_ids[position] = n_id # <<<<<<<<<<<<<< + * + * if n_pos != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 395, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_id, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 395, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":394 + * self.c_names[position] = n_name + * + * if n_id != "null": # <<<<<<<<<<<<<< + * self.c_ids[position] = n_id + * + */ + } + + /* "analysis.py":397 + * self.c_ids[position] = n_id + * + * if n_pos != "null": # <<<<<<<<<<<<<< + * self.c_pos[position] = n_pos + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_pos, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 397, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":398 + * + * if n_pos != "null": + * self.c_pos[position] = n_pos # <<<<<<<<<<<<<< + * + * if n_effect != "null": + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_pos, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 398, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":397 + * self.c_ids[position] = n_id + * + * if n_pos != "null": # <<<<<<<<<<<<<< + * self.c_pos[position] = n_pos + * + */ + } + + /* "analysis.py":400 + * self.c_pos[position] = n_pos + * + * if n_effect != "null": # <<<<<<<<<<<<<< + * self.c_effects[position] = n_effect + * + */ + __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_n_effect, __pyx_n_s_null, Py_NE)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 400, __pyx_L1_error) + if (__pyx_t_6) { + + /* "analysis.py":401 + * + * if n_effect != "null": + * self.c_effects[position] = n_effect # <<<<<<<<<<<<<< + * + * return None + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 401, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_SetItemInt(__pyx_t_1, __pyx_v_position, __pyx_v_n_effect, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) < 0)) __PYX_ERR(0, 401, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":400 + * self.c_pos[position] = n_pos + * + * if n_effect != "null": # <<<<<<<<<<<<<< + * self.c_effects[position] = n_effect + * + */ + } + + /* "analysis.py":403 + * self.c_effects[position] = n_effect + * + * return None # <<<<<<<<<<<<<< + * + * def search(self, search): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "analysis.py":384 + * return None + * + * def edit(self, search, n_name, n_id, n_pos, n_effect): # <<<<<<<<<<<<<< + * position = 0 + * print(self.c_ids) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("analysis.objectives.edit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":405 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_10objectives_9search(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_10objectives_9search = {"search", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_10objectives_9search, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_10objectives_9search(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_search = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("search (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_search,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_self)) != 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_search)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("search", 1, 2, 2, 1); __PYX_ERR(0, 405, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "search") < 0)) __PYX_ERR(0, 405, __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_self = values[0]; + __pyx_v_search = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("search", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 405, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.objectives.search", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_10objectives_8search(__pyx_self, __pyx_v_self, __pyx_v_search); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_10objectives_8search(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_search) { + Py_ssize_t __pyx_v_position; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("search", 0); + + /* "analysis.py":406 + * + * def search(self, search): + * position = 0 # <<<<<<<<<<<<<< + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + */ + __pyx_v_position = 0; + + /* "analysis.py":407 + * def search(self, search): + * position = 0 + * for i in range(0, len(self.c_ids), 1): # <<<<<<<<<<<<<< + * if self.c_ids[i] == search: + * position = i + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 407, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "analysis.py":408 + * position = 0 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 408, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 408, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_v_search, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 408, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 408, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_6) { + + /* "analysis.py":409 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: + * position = i # <<<<<<<<<<<<<< + * + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_effects[position]] + */ + __pyx_v_position = __pyx_v_i; + + /* "analysis.py":408 + * position = 0 + * for i in range(0, len(self.c_ids), 1): + * if self.c_ids[i] == search: # <<<<<<<<<<<<<< + * position = i + * + */ + } + } + + /* "analysis.py":411 + * position = i + * + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_effects[position]] # <<<<<<<<<<<<<< + * + * def regurgitate(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_position, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyList_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_5); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_7); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_8); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_t_8); + __Pyx_GIVEREF(__pyx_t_9); + PyList_SET_ITEM(__pyx_t_1, 3, __pyx_t_9); + __pyx_t_5 = 0; + __pyx_t_7 = 0; + __pyx_t_8 = 0; + __pyx_t_9 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "analysis.py":405 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("analysis.objectives.search", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":413 + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_effects[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * return[self.c_names, self.c_ids, self.c_pos, self.c_effects] + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_10objectives_11regurgitate(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_10objectives_11regurgitate = {"regurgitate", (PyCFunction)__pyx_pw_8analysis_10objectives_11regurgitate, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_10objectives_11regurgitate(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("regurgitate (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_10objectives_10regurgitate(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_10objectives_10regurgitate(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + 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; + __Pyx_RefNannySetupContext("regurgitate", 0); + + /* "analysis.py":414 + * + * def regurgitate(self): + * return[self.c_names, self.c_ids, self.c_pos, self.c_effects] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_ids); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_pos); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_c_effects); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyList_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyList_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyList_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyList_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "analysis.py":413 + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_effects[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * return[self.c_names, self.c_ids, self.c_pos, self.c_effects] + * + */ + + /* 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("analysis.objectives.regurgitate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":417 + * + * + * def load_csv(filepath): # <<<<<<<<<<<<<< + * with open(filepath, newline='') as csvfile: + * file_array = list(csv.reader(csvfile)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_3load_csv(PyObject *__pyx_self, PyObject *__pyx_v_filepath); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_3load_csv = {"load_csv", (PyCFunction)__pyx_pw_8analysis_3load_csv, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_3load_csv(PyObject *__pyx_self, PyObject *__pyx_v_filepath) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("load_csv (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_2load_csv(__pyx_self, ((PyObject *)__pyx_v_filepath)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_2load_csv(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_filepath) { + PyObject *__pyx_v_csvfile = NULL; + PyObject *__pyx_v_file_array = 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 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + int __pyx_t_11; + __Pyx_RefNannySetupContext("load_csv", 0); + + /* "analysis.py":418 + * + * def load_csv(filepath): + * with open(filepath, newline='') as csvfile: # <<<<<<<<<<<<<< + * file_array = list(csv.reader(csvfile)) + * csvfile.close() + */ + /*with:*/ { + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_filepath); + __Pyx_GIVEREF(__pyx_v_filepath); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_filepath); + __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_newline, __pyx_kp_s__2) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_open, __pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 418, __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_t_4 = __Pyx_PyObject_LookupSpecial(__pyx_t_3, __pyx_n_s_exit); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_LookupSpecial(__pyx_t_3, __pyx_n_s_enter); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 418, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + /*try:*/ { + __pyx_v_csvfile = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":419 + * def load_csv(filepath): + * with open(filepath, newline='') as csvfile: + * file_array = list(csv.reader(csvfile)) # <<<<<<<<<<<<<< + * csvfile.close() + * return file_array + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_csv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 419, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_reader); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 419, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __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_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_csvfile) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_csvfile); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 419, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 419, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_file_array = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":420 + * with open(filepath, newline='') as csvfile: + * file_array = list(csv.reader(csvfile)) + * csvfile.close() # <<<<<<<<<<<<<< + * return file_array + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_csvfile, __pyx_n_s_close); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 420, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 420, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":418 + * + * def load_csv(filepath): + * with open(filepath, newline='') as csvfile: # <<<<<<<<<<<<<< + * file_array = list(csv.reader(csvfile)) + * csvfile.close() + */ + } + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L12_try_end; + __pyx_L7_error:; + __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; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + /*except:*/ { + __Pyx_AddTraceback("analysis.load_csv", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_1, &__pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 418, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 418, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (__pyx_t_10 < 0) __PYX_ERR(0, 418, __pyx_L9_except_error) + __pyx_t_11 = ((!(__pyx_t_10 != 0)) != 0); + if (__pyx_t_11) { + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_1, __pyx_t_3); + __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_3 = 0; + __PYX_ERR(0, 418, __pyx_L9_except_error) + } + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_exception_handled; + } + __pyx_L9_except_error:; + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + goto __pyx_L1_error; + __pyx_L8_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + __pyx_L12_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_4) { + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__3, NULL); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + goto __pyx_L6; + } + __pyx_L6:; + } + goto __pyx_L16; + __pyx_L3_error:; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L1_error; + __pyx_L16:; + } + + /* "analysis.py":421 + * file_array = list(csv.reader(csvfile)) + * csvfile.close() + * return file_array # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + if (unlikely(!__pyx_v_file_array)) { __Pyx_RaiseUnboundLocalError("file_array"); __PYX_ERR(0, 421, __pyx_L1_error) } + __Pyx_INCREF(__pyx_v_file_array); + __pyx_r = __pyx_v_file_array; + goto __pyx_L0; + + /* "analysis.py":417 + * + * + * def load_csv(filepath): # <<<<<<<<<<<<<< + * with open(filepath, newline='') as csvfile: + * file_array = list(csv.reader(csvfile)) + */ + + /* 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_5); + __Pyx_AddTraceback("analysis.load_csv", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_csvfile); + __Pyx_XDECREF(__pyx_v_file_array); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":425 + * + * # data=array, mode = ['1d':1d_basic_stats, 'column':c_basic_stats, 'row':r_basic_stats], arg for mode 1 or mode 2 for column or row + * def basic_stats(data, method, arg): # <<<<<<<<<<<<<< + * + * if method == 'debug': + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_5basic_stats(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_5basic_stats = {"basic_stats", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_5basic_stats, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_5basic_stats(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_data = 0; + PyObject *__pyx_v_method = 0; + PyObject *__pyx_v_arg = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("basic_stats (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_data,&__pyx_n_s_method,&__pyx_n_s_arg,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_data)) != 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_method)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("basic_stats", 1, 3, 3, 1); __PYX_ERR(0, 425, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arg)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("basic_stats", 1, 3, 3, 2); __PYX_ERR(0, 425, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "basic_stats") < 0)) __PYX_ERR(0, 425, __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_data = values[0]; + __pyx_v_method = values[1]; + __pyx_v_arg = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("basic_stats", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 425, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.basic_stats", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_4basic_stats(__pyx_self, __pyx_v_data, __pyx_v_method, __pyx_v_arg); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_4basic_stats(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data, PyObject *__pyx_v_method, PyObject *__pyx_v_arg) { + PyObject *__pyx_v_data_t = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v__mean = NULL; + PyObject *__pyx_v__median = NULL; + PyObject *__pyx_v__mode = NULL; + PyObject *__pyx_v__stdev = NULL; + PyObject *__pyx_v__variance = NULL; + PyObject *__pyx_v_c_data = NULL; + CYTHON_UNUSED PyObject *__pyx_v_c_data_sorted = NULL; + PyObject *__pyx_v_r_data = NULL; + 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; + PyObject *__pyx_t_5 = NULL; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + __Pyx_RefNannySetupContext("basic_stats", 0); + + /* "analysis.py":427 + * def basic_stats(data, method, arg): + * + * if method == 'debug': # <<<<<<<<<<<<<< + * return "basic_stats requires 3 args: data, mode, arg; where data is data to be analyzed, mode is an int from 0 - 2 depending on type of analysis (by column or by row) and is only applicable to 2d arrays (for 1d arrays use mode 1), and arg is row/column number for mode 1 or mode 2; function returns: [mean, median, mode, stdev, variance]" + * + */ + __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_method, __pyx_n_s_debug, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 427, __pyx_L1_error) + if (__pyx_t_1) { + + /* "analysis.py":428 + * + * if method == 'debug': + * return "basic_stats requires 3 args: data, mode, arg; where data is data to be analyzed, mode is an int from 0 - 2 depending on type of analysis (by column or by row) and is only applicable to 2d arrays (for 1d arrays use mode 1), and arg is row/column number for mode 1 or mode 2; function returns: [mean, median, mode, stdev, variance]" # <<<<<<<<<<<<<< + * + * if method == "1d" or method == 0: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_kp_s_basic_stats_requires_3_args_data); + __pyx_r = __pyx_kp_s_basic_stats_requires_3_args_data; + goto __pyx_L0; + + /* "analysis.py":427 + * def basic_stats(data, method, arg): + * + * if method == 'debug': # <<<<<<<<<<<<<< + * return "basic_stats requires 3 args: data, mode, arg; where data is data to be analyzed, mode is an int from 0 - 2 depending on type of analysis (by column or by row) and is only applicable to 2d arrays (for 1d arrays use mode 1), and arg is row/column number for mode 1 or mode 2; function returns: [mean, median, mode, stdev, variance]" + * + */ + } + + /* "analysis.py":430 + * return "basic_stats requires 3 args: data, mode, arg; where data is data to be analyzed, mode is an int from 0 - 2 depending on type of analysis (by column or by row) and is only applicable to 2d arrays (for 1d arrays use mode 1), and arg is row/column number for mode 1 or mode 2; function returns: [mean, median, mode, stdev, variance]" + * + * if method == "1d" or method == 0: # <<<<<<<<<<<<<< + * + * data_t = [] + */ + __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_method, __pyx_kp_s_1d, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 430, __pyx_L1_error) + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_method, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 430, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_t_2; + __pyx_L5_bool_binop_done:; + if (__pyx_t_1) { + + /* "analysis.py":432 + * if method == "1d" or method == 0: + * + * data_t = [] # <<<<<<<<<<<<<< + * + * for i in range(0, len(data), 1): + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_data_t = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":434 + * data_t = [] + * + * for i in range(0, len(data), 1): # <<<<<<<<<<<<<< + * data_t.append(float(data[i])) + * + */ + __pyx_t_4 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 434, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_int_1); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_5 = __pyx_t_3; __Pyx_INCREF(__pyx_t_5); __pyx_t_4 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_4 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 434, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_5))) { + if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_5)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 434, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_5, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_5)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 434, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_5, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_6(__pyx_t_5); + 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(0, 434, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":435 + * + * for i in range(0, len(data), 1): + * data_t.append(float(data[i])) # <<<<<<<<<<<<<< + * + * _mean = mean(data_t) + */ + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_data, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyNumber_Float(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_data_t, __pyx_t_7); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "analysis.py":434 + * data_t = [] + * + * for i in range(0, len(data), 1): # <<<<<<<<<<<<<< + * data_t.append(float(data[i])) + * + */ + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "analysis.py":437 + * data_t.append(float(data[i])) + * + * _mean = mean(data_t) # <<<<<<<<<<<<<< + * _median = median(data_t) + * try: + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_mean); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_5 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_3, __pyx_v_data_t) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data_t); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v__mean = __pyx_t_5; + __pyx_t_5 = 0; + + /* "analysis.py":438 + * + * _mean = mean(data_t) + * _median = median(data_t) # <<<<<<<<<<<<<< + * try: + * _mode = mode(data_t) + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_median); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_5 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_3, __pyx_v_data_t) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data_t); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v__median = __pyx_t_5; + __pyx_t_5 = 0; + + /* "analysis.py":439 + * _mean = mean(data_t) + * _median = median(data_t) + * try: # <<<<<<<<<<<<<< + * _mode = mode(data_t) + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + /*try:*/ { + + /* "analysis.py":440 + * _median = median(data_t) + * try: + * _mode = mode(data_t) # <<<<<<<<<<<<<< + * except: + * _mode = None + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_mode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 440, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_5 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_3, __pyx_v_data_t) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data_t); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 440, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v__mode = __pyx_t_5; + __pyx_t_5 = 0; + + /* "analysis.py":439 + * _mean = mean(data_t) + * _median = median(data_t) + * try: # <<<<<<<<<<<<<< + * _mode = mode(data_t) + * except: + */ + } + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + goto __pyx_L14_try_end; + __pyx_L9_error:; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "analysis.py":441 + * try: + * _mode = mode(data_t) + * except: # <<<<<<<<<<<<<< + * _mode = None + * try: + */ + /*except:*/ { + __Pyx_AddTraceback("analysis.basic_stats", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_7, &__pyx_t_3) < 0) __PYX_ERR(0, 441, __pyx_L11_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_3); + + /* "analysis.py":442 + * _mode = mode(data_t) + * except: + * _mode = None # <<<<<<<<<<<<<< + * try: + * _stdev = stdev(data_t) + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v__mode, Py_None); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L10_exception_handled; + } + __pyx_L11_except_error:; + + /* "analysis.py":439 + * _mean = mean(data_t) + * _median = median(data_t) + * try: # <<<<<<<<<<<<<< + * _mode = mode(data_t) + * except: + */ + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); + goto __pyx_L1_error; + __pyx_L10_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); + __pyx_L14_try_end:; + } + + /* "analysis.py":443 + * except: + * _mode = None + * try: # <<<<<<<<<<<<<< + * _stdev = stdev(data_t) + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + + /* "analysis.py":444 + * _mode = None + * try: + * _stdev = stdev(data_t) # <<<<<<<<<<<<<< + * except: + * _stdev = None + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_stdev); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 444, __pyx_L17_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_5, __pyx_v_data_t) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data_t); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 444, __pyx_L17_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v__stdev = __pyx_t_3; + __pyx_t_3 = 0; + + /* "analysis.py":443 + * except: + * _mode = None + * try: # <<<<<<<<<<<<<< + * _stdev = stdev(data_t) + * except: + */ + } + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L22_try_end; + __pyx_L17_error:; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "analysis.py":445 + * try: + * _stdev = stdev(data_t) + * except: # <<<<<<<<<<<<<< + * _stdev = None + * try: + */ + /*except:*/ { + __Pyx_AddTraceback("analysis.basic_stats", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_7, &__pyx_t_5) < 0) __PYX_ERR(0, 445, __pyx_L19_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_5); + + /* "analysis.py":446 + * _stdev = stdev(data_t) + * except: + * _stdev = None # <<<<<<<<<<<<<< + * try: + * _variance = variance(data_t) + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v__stdev, Py_None); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L18_exception_handled; + } + __pyx_L19_except_error:; + + /* "analysis.py":443 + * except: + * _mode = None + * try: # <<<<<<<<<<<<<< + * _stdev = stdev(data_t) + * except: + */ + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L18_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9); + __pyx_L22_try_end:; + } + + /* "analysis.py":447 + * except: + * _stdev = None + * try: # <<<<<<<<<<<<<< + * _variance = variance(data_t) + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + /*try:*/ { + + /* "analysis.py":448 + * _stdev = None + * try: + * _variance = variance(data_t) # <<<<<<<<<<<<<< + * except: + * _variance = None + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_variance); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 448, __pyx_L25_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_5 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_3, __pyx_v_data_t) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data_t); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 448, __pyx_L25_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v__variance = __pyx_t_5; + __pyx_t_5 = 0; + + /* "analysis.py":447 + * except: + * _stdev = None + * try: # <<<<<<<<<<<<<< + * _variance = variance(data_t) + * except: + */ + } + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + goto __pyx_L30_try_end; + __pyx_L25_error:; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "analysis.py":449 + * try: + * _variance = variance(data_t) + * except: # <<<<<<<<<<<<<< + * _variance = None + * + */ + /*except:*/ { + __Pyx_AddTraceback("analysis.basic_stats", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_7, &__pyx_t_3) < 0) __PYX_ERR(0, 449, __pyx_L27_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_3); + + /* "analysis.py":450 + * _variance = variance(data_t) + * except: + * _variance = None # <<<<<<<<<<<<<< + * + * return _mean, _median, _mode, _stdev, _variance + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v__variance, Py_None); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L26_exception_handled; + } + __pyx_L27_except_error:; + + /* "analysis.py":447 + * except: + * _stdev = None + * try: # <<<<<<<<<<<<<< + * _variance = variance(data_t) + * except: + */ + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); + goto __pyx_L1_error; + __pyx_L26_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); + __pyx_L30_try_end:; + } + + /* "analysis.py":452 + * _variance = None + * + * return _mean, _median, _mode, _stdev, _variance # <<<<<<<<<<<<<< + * + * elif method == "column" or method == 1: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyTuple_New(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v__mean); + __Pyx_GIVEREF(__pyx_v__mean); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v__mean); + __Pyx_INCREF(__pyx_v__median); + __Pyx_GIVEREF(__pyx_v__median); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v__median); + __Pyx_INCREF(__pyx_v__mode); + __Pyx_GIVEREF(__pyx_v__mode); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v__mode); + __Pyx_INCREF(__pyx_v__stdev); + __Pyx_GIVEREF(__pyx_v__stdev); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_v__stdev); + __Pyx_INCREF(__pyx_v__variance); + __Pyx_GIVEREF(__pyx_v__variance); + PyTuple_SET_ITEM(__pyx_t_3, 4, __pyx_v__variance); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "analysis.py":430 + * return "basic_stats requires 3 args: data, mode, arg; where data is data to be analyzed, mode is an int from 0 - 2 depending on type of analysis (by column or by row) and is only applicable to 2d arrays (for 1d arrays use mode 1), and arg is row/column number for mode 1 or mode 2; function returns: [mean, median, mode, stdev, variance]" + * + * if method == "1d" or method == 0: # <<<<<<<<<<<<<< + * + * data_t = [] + */ + } + + /* "analysis.py":454 + * return _mean, _median, _mode, _stdev, _variance + * + * elif method == "column" or method == 1: # <<<<<<<<<<<<<< + * + * c_data = [] + */ + __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_method, __pyx_n_s_column, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 454, __pyx_L1_error) + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L33_bool_binop_done; + } + __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_method, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_t_2; + __pyx_L33_bool_binop_done:; + if (__pyx_t_1) { + + /* "analysis.py":456 + * elif method == "column" or method == 1: + * + * c_data = [] # <<<<<<<<<<<<<< + * c_data_sorted = [] + * + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_c_data = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":457 + * + * c_data = [] + * c_data_sorted = [] # <<<<<<<<<<<<<< + * + * for i in data: + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 457, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_c_data_sorted = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":459 + * c_data_sorted = [] + * + * for i in data: # <<<<<<<<<<<<<< + * try: + * c_data.append(float(i[arg])) + */ + if (likely(PyList_CheckExact(__pyx_v_data)) || PyTuple_CheckExact(__pyx_v_data)) { + __pyx_t_3 = __pyx_v_data; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_data); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 459, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 459, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_7); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 459, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 459, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } else { + if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_7); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 459, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 459, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } + } else { + __pyx_t_7 = __pyx_t_6(__pyx_t_3); + 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(0, 459, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_7); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_7); + __pyx_t_7 = 0; + + /* "analysis.py":460 + * + * for i in data: + * try: # <<<<<<<<<<<<<< + * c_data.append(float(i[arg])) + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + + /* "analysis.py":461 + * for i in data: + * try: + * c_data.append(float(i[arg])) # <<<<<<<<<<<<<< + * except: + * pass + */ + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_i, __pyx_v_arg); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 461, __pyx_L37_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyNumber_Float(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 461, __pyx_L37_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_c_data, __pyx_t_5); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 461, __pyx_L37_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "analysis.py":460 + * + * for i in data: + * try: # <<<<<<<<<<<<<< + * c_data.append(float(i[arg])) + * except: + */ + } + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L44_try_end; + __pyx_L37_error:; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "analysis.py":462 + * try: + * c_data.append(float(i[arg])) + * except: # <<<<<<<<<<<<<< + * pass + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L38_exception_handled; + } + __pyx_L38_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9); + __pyx_L44_try_end:; + } + + /* "analysis.py":459 + * c_data_sorted = [] + * + * for i in data: # <<<<<<<<<<<<<< + * try: + * c_data.append(float(i[arg])) + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "analysis.py":465 + * pass + * + * _mean = mean(c_data) # <<<<<<<<<<<<<< + * _median = median(c_data) + * try: + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_mean); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 465, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_v_c_data) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_c_data); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 465, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v__mean = __pyx_t_3; + __pyx_t_3 = 0; + + /* "analysis.py":466 + * + * _mean = mean(c_data) + * _median = median(c_data) # <<<<<<<<<<<<<< + * try: + * _mode = mode(c_data) + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_median); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_v_c_data) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_c_data); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v__median = __pyx_t_3; + __pyx_t_3 = 0; + + /* "analysis.py":467 + * _mean = mean(c_data) + * _median = median(c_data) + * try: # <<<<<<<<<<<<<< + * _mode = mode(c_data) + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + /*try:*/ { + + /* "analysis.py":468 + * _median = median(c_data) + * try: + * _mode = mode(c_data) # <<<<<<<<<<<<<< + * except: + * _mode = None + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_mode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 468, __pyx_L45_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_v_c_data) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_c_data); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 468, __pyx_L45_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v__mode = __pyx_t_3; + __pyx_t_3 = 0; + + /* "analysis.py":467 + * _mean = mean(c_data) + * _median = median(c_data) + * try: # <<<<<<<<<<<<<< + * _mode = mode(c_data) + * except: + */ + } + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + goto __pyx_L50_try_end; + __pyx_L45_error:; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "analysis.py":469 + * try: + * _mode = mode(c_data) + * except: # <<<<<<<<<<<<<< + * _mode = None + * try: + */ + /*except:*/ { + __Pyx_AddTraceback("analysis.basic_stats", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_5, &__pyx_t_7) < 0) __PYX_ERR(0, 469, __pyx_L47_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_7); + + /* "analysis.py":470 + * _mode = mode(c_data) + * except: + * _mode = None # <<<<<<<<<<<<<< + * try: + * _stdev = stdev(c_data) + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v__mode, Py_None); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L46_exception_handled; + } + __pyx_L47_except_error:; + + /* "analysis.py":467 + * _mean = mean(c_data) + * _median = median(c_data) + * try: # <<<<<<<<<<<<<< + * _mode = mode(c_data) + * except: + */ + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); + goto __pyx_L1_error; + __pyx_L46_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); + __pyx_L50_try_end:; + } + + /* "analysis.py":471 + * except: + * _mode = None + * try: # <<<<<<<<<<<<<< + * _stdev = stdev(c_data) + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + + /* "analysis.py":472 + * _mode = None + * try: + * _stdev = stdev(c_data) # <<<<<<<<<<<<<< + * except: + * _stdev = None + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_stdev); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 472, __pyx_L53_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_7 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_3, __pyx_v_c_data) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_c_data); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 472, __pyx_L53_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v__stdev = __pyx_t_7; + __pyx_t_7 = 0; + + /* "analysis.py":471 + * except: + * _mode = None + * try: # <<<<<<<<<<<<<< + * _stdev = stdev(c_data) + * except: + */ + } + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L58_try_end; + __pyx_L53_error:; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "analysis.py":473 + * try: + * _stdev = stdev(c_data) + * except: # <<<<<<<<<<<<<< + * _stdev = None + * try: + */ + /*except:*/ { + __Pyx_AddTraceback("analysis.basic_stats", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_5, &__pyx_t_3) < 0) __PYX_ERR(0, 473, __pyx_L55_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_3); + + /* "analysis.py":474 + * _stdev = stdev(c_data) + * except: + * _stdev = None # <<<<<<<<<<<<<< + * try: + * _variance = variance(c_data) + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v__stdev, Py_None); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L54_exception_handled; + } + __pyx_L55_except_error:; + + /* "analysis.py":471 + * except: + * _mode = None + * try: # <<<<<<<<<<<<<< + * _stdev = stdev(c_data) + * except: + */ + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L54_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9); + __pyx_L58_try_end:; + } + + /* "analysis.py":475 + * except: + * _stdev = None + * try: # <<<<<<<<<<<<<< + * _variance = variance(c_data) + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + /*try:*/ { + + /* "analysis.py":476 + * _stdev = None + * try: + * _variance = variance(c_data) # <<<<<<<<<<<<<< + * except: + * _variance = None + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_variance); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 476, __pyx_L61_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_v_c_data) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_c_data); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 476, __pyx_L61_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v__variance = __pyx_t_3; + __pyx_t_3 = 0; + + /* "analysis.py":475 + * except: + * _stdev = None + * try: # <<<<<<<<<<<<<< + * _variance = variance(c_data) + * except: + */ + } + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + goto __pyx_L66_try_end; + __pyx_L61_error:; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "analysis.py":477 + * try: + * _variance = variance(c_data) + * except: # <<<<<<<<<<<<<< + * _variance = None + * + */ + /*except:*/ { + __Pyx_AddTraceback("analysis.basic_stats", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_5, &__pyx_t_7) < 0) __PYX_ERR(0, 477, __pyx_L63_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_7); + + /* "analysis.py":478 + * _variance = variance(c_data) + * except: + * _variance = None # <<<<<<<<<<<<<< + * + * return _mean, _median, _mode, _stdev, _variance + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v__variance, Py_None); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L62_exception_handled; + } + __pyx_L63_except_error:; + + /* "analysis.py":475 + * except: + * _stdev = None + * try: # <<<<<<<<<<<<<< + * _variance = variance(c_data) + * except: + */ + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); + goto __pyx_L1_error; + __pyx_L62_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); + __pyx_L66_try_end:; + } + + /* "analysis.py":480 + * _variance = None + * + * return _mean, _median, _mode, _stdev, _variance # <<<<<<<<<<<<<< + * + * elif method == "row" or method == 2: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 480, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_v__mean); + __Pyx_GIVEREF(__pyx_v__mean); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_v__mean); + __Pyx_INCREF(__pyx_v__median); + __Pyx_GIVEREF(__pyx_v__median); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_v__median); + __Pyx_INCREF(__pyx_v__mode); + __Pyx_GIVEREF(__pyx_v__mode); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v__mode); + __Pyx_INCREF(__pyx_v__stdev); + __Pyx_GIVEREF(__pyx_v__stdev); + PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_v__stdev); + __Pyx_INCREF(__pyx_v__variance); + __Pyx_GIVEREF(__pyx_v__variance); + PyTuple_SET_ITEM(__pyx_t_7, 4, __pyx_v__variance); + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L0; + + /* "analysis.py":454 + * return _mean, _median, _mode, _stdev, _variance + * + * elif method == "column" or method == 1: # <<<<<<<<<<<<<< + * + * c_data = [] + */ + } + + /* "analysis.py":482 + * return _mean, _median, _mode, _stdev, _variance + * + * elif method == "row" or method == 2: # <<<<<<<<<<<<<< + * + * r_data = [] + */ + __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_method, __pyx_n_s_row, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 482, __pyx_L1_error) + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L69_bool_binop_done; + } + __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_v_method, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_1 = __pyx_t_2; + __pyx_L69_bool_binop_done:; + if (likely(__pyx_t_1)) { + + /* "analysis.py":484 + * elif method == "row" or method == 2: + * + * r_data = [] # <<<<<<<<<<<<<< + * + * for i in range(len(data[arg])): + */ + __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_v_r_data = ((PyObject*)__pyx_t_7); + __pyx_t_7 = 0; + + /* "analysis.py":486 + * r_data = [] + * + * for i in range(len(data[arg])): # <<<<<<<<<<<<<< + * r_data.append(float(data[arg][i])) + * + */ + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_data, __pyx_v_arg); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = PyObject_Length(__pyx_t_7); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) { + __pyx_t_7 = __pyx_t_5; __Pyx_INCREF(__pyx_t_7); __pyx_t_4 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_4 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 486, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_7))) { + if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_7)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_4); __Pyx_INCREF(__pyx_t_5); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 486, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_7, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_7)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_4); __Pyx_INCREF(__pyx_t_5); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 486, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_7, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_6(__pyx_t_7); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 486, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_5); + __pyx_t_5 = 0; + + /* "analysis.py":487 + * + * for i in range(len(data[arg])): + * r_data.append(float(data[arg][i])) # <<<<<<<<<<<<<< + * + * _mean = mean(r_data) + */ + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_data, __pyx_v_arg); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyNumber_Float(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_r_data, __pyx_t_5); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 487, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "analysis.py":486 + * r_data = [] + * + * for i in range(len(data[arg])): # <<<<<<<<<<<<<< + * r_data.append(float(data[arg][i])) + * + */ + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "analysis.py":489 + * r_data.append(float(data[arg][i])) + * + * _mean = mean(r_data) # <<<<<<<<<<<<<< + * _median = median(r_data) + * try: + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_mean); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_7 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_3, __pyx_v_r_data) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_r_data); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v__mean = __pyx_t_7; + __pyx_t_7 = 0; + + /* "analysis.py":490 + * + * _mean = mean(r_data) + * _median = median(r_data) # <<<<<<<<<<<<<< + * try: + * _mode = mode(r_data) + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_median); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_7 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_3, __pyx_v_r_data) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_r_data); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v__median = __pyx_t_7; + __pyx_t_7 = 0; + + /* "analysis.py":491 + * _mean = mean(r_data) + * _median = median(r_data) + * try: # <<<<<<<<<<<<<< + * _mode = mode(r_data) + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + + /* "analysis.py":492 + * _median = median(r_data) + * try: + * _mode = mode(r_data) # <<<<<<<<<<<<<< + * except: + * _mode = None + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_mode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 492, __pyx_L73_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_7 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_3, __pyx_v_r_data) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_r_data); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 492, __pyx_L73_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v__mode = __pyx_t_7; + __pyx_t_7 = 0; + + /* "analysis.py":491 + * _mean = mean(r_data) + * _median = median(r_data) + * try: # <<<<<<<<<<<<<< + * _mode = mode(r_data) + * except: + */ + } + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L78_try_end; + __pyx_L73_error:; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "analysis.py":493 + * try: + * _mode = mode(r_data) + * except: # <<<<<<<<<<<<<< + * _mode = None + * try: + */ + /*except:*/ { + __Pyx_AddTraceback("analysis.basic_stats", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_5, &__pyx_t_3) < 0) __PYX_ERR(0, 493, __pyx_L75_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_3); + + /* "analysis.py":494 + * _mode = mode(r_data) + * except: + * _mode = None # <<<<<<<<<<<<<< + * try: + * _stdev = stdev(r_data) + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v__mode, Py_None); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L74_exception_handled; + } + __pyx_L75_except_error:; + + /* "analysis.py":491 + * _mean = mean(r_data) + * _median = median(r_data) + * try: # <<<<<<<<<<<<<< + * _mode = mode(r_data) + * except: + */ + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L74_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9); + __pyx_L78_try_end:; + } + + /* "analysis.py":495 + * except: + * _mode = None + * try: # <<<<<<<<<<<<<< + * _stdev = stdev(r_data) + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + /*try:*/ { + + /* "analysis.py":496 + * _mode = None + * try: + * _stdev = stdev(r_data) # <<<<<<<<<<<<<< + * except: + * _stdev = None + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_stdev); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 496, __pyx_L81_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_v_r_data) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_r_data); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 496, __pyx_L81_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v__stdev = __pyx_t_3; + __pyx_t_3 = 0; + + /* "analysis.py":495 + * except: + * _mode = None + * try: # <<<<<<<<<<<<<< + * _stdev = stdev(r_data) + * except: + */ + } + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + goto __pyx_L86_try_end; + __pyx_L81_error:; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "analysis.py":497 + * try: + * _stdev = stdev(r_data) + * except: # <<<<<<<<<<<<<< + * _stdev = None + * try: + */ + /*except:*/ { + __Pyx_AddTraceback("analysis.basic_stats", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_5, &__pyx_t_7) < 0) __PYX_ERR(0, 497, __pyx_L83_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_7); + + /* "analysis.py":498 + * _stdev = stdev(r_data) + * except: + * _stdev = None # <<<<<<<<<<<<<< + * try: + * _variance = variance(r_data) + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v__stdev, Py_None); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L82_exception_handled; + } + __pyx_L83_except_error:; + + /* "analysis.py":495 + * except: + * _mode = None + * try: # <<<<<<<<<<<<<< + * _stdev = stdev(r_data) + * except: + */ + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); + goto __pyx_L1_error; + __pyx_L82_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); + __pyx_L86_try_end:; + } + + /* "analysis.py":499 + * except: + * _stdev = None + * try: # <<<<<<<<<<<<<< + * _variance = variance(r_data) + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + + /* "analysis.py":500 + * _stdev = None + * try: + * _variance = variance(r_data) # <<<<<<<<<<<<<< + * except: + * _variance = None + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_variance); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 500, __pyx_L89_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_7 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_3, __pyx_v_r_data) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_r_data); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 500, __pyx_L89_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v__variance = __pyx_t_7; + __pyx_t_7 = 0; + + /* "analysis.py":499 + * except: + * _stdev = None + * try: # <<<<<<<<<<<<<< + * _variance = variance(r_data) + * except: + */ + } + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L94_try_end; + __pyx_L89_error:; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "analysis.py":501 + * try: + * _variance = variance(r_data) + * except: # <<<<<<<<<<<<<< + * _variance = None + * + */ + /*except:*/ { + __Pyx_AddTraceback("analysis.basic_stats", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_5, &__pyx_t_3) < 0) __PYX_ERR(0, 501, __pyx_L91_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_3); + + /* "analysis.py":502 + * _variance = variance(r_data) + * except: + * _variance = None # <<<<<<<<<<<<<< + * + * return _mean, _median, _mode, _stdev, _variance + */ + __Pyx_INCREF(Py_None); + __Pyx_XDECREF_SET(__pyx_v__variance, Py_None); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L90_exception_handled; + } + __pyx_L91_except_error:; + + /* "analysis.py":499 + * except: + * _stdev = None + * try: # <<<<<<<<<<<<<< + * _variance = variance(r_data) + * except: + */ + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L90_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9); + __pyx_L94_try_end:; + } + + /* "analysis.py":504 + * _variance = None + * + * return _mean, _median, _mode, _stdev, _variance # <<<<<<<<<<<<<< + * + * else: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyTuple_New(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v__mean); + __Pyx_GIVEREF(__pyx_v__mean); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v__mean); + __Pyx_INCREF(__pyx_v__median); + __Pyx_GIVEREF(__pyx_v__median); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v__median); + __Pyx_INCREF(__pyx_v__mode); + __Pyx_GIVEREF(__pyx_v__mode); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v__mode); + __Pyx_INCREF(__pyx_v__stdev); + __Pyx_GIVEREF(__pyx_v__stdev); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_v__stdev); + __Pyx_INCREF(__pyx_v__variance); + __Pyx_GIVEREF(__pyx_v__variance); + PyTuple_SET_ITEM(__pyx_t_3, 4, __pyx_v__variance); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "analysis.py":482 + * return _mean, _median, _mode, _stdev, _variance + * + * elif method == "row" or method == 2: # <<<<<<<<<<<<<< + * + * r_data = [] + */ + } + + /* "analysis.py":507 + * + * else: + * raise error("method error") # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_kp_s_method_error) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_kp_s_method_error); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 507, __pyx_L1_error) + } + + /* "analysis.py":425 + * + * # data=array, mode = ['1d':1d_basic_stats, 'column':c_basic_stats, 'row':r_basic_stats], arg for mode 1 or mode 2 for column or row + * def basic_stats(data, method, arg): # <<<<<<<<<<<<<< + * + * if method == 'debug': + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("analysis.basic_stats", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_data_t); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v__mean); + __Pyx_XDECREF(__pyx_v__median); + __Pyx_XDECREF(__pyx_v__mode); + __Pyx_XDECREF(__pyx_v__stdev); + __Pyx_XDECREF(__pyx_v__variance); + __Pyx_XDECREF(__pyx_v_c_data); + __Pyx_XDECREF(__pyx_v_c_data_sorted); + __Pyx_XDECREF(__pyx_v_r_data); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":511 + * + * # returns z score with inputs of point, mean and standard deviation of spread + * def z_score(point, mean, stdev): # <<<<<<<<<<<<<< + * score = (point - mean) / stdev + * return score + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_7z_score(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_7z_score = {"z_score", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_7z_score, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_7z_score(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_point = 0; + PyObject *__pyx_v_mean = 0; + PyObject *__pyx_v_stdev = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("z_score (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_point,&__pyx_n_s_mean,&__pyx_n_s_stdev,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_point)) != 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_mean)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("z_score", 1, 3, 3, 1); __PYX_ERR(0, 511, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_stdev)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("z_score", 1, 3, 3, 2); __PYX_ERR(0, 511, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "z_score") < 0)) __PYX_ERR(0, 511, __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_point = values[0]; + __pyx_v_mean = values[1]; + __pyx_v_stdev = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("z_score", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 511, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.z_score", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_6z_score(__pyx_self, __pyx_v_point, __pyx_v_mean, __pyx_v_stdev); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_6z_score(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_point, PyObject *__pyx_v_mean, PyObject *__pyx_v_stdev) { + PyObject *__pyx_v_score = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("z_score", 0); + + /* "analysis.py":512 + * # returns z score with inputs of point, mean and standard deviation of spread + * def z_score(point, mean, stdev): + * score = (point - mean) / stdev # <<<<<<<<<<<<<< + * return score + * + */ + __pyx_t_1 = PyNumber_Subtract(__pyx_v_point, __pyx_v_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_v_stdev); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_score = __pyx_t_2; + __pyx_t_2 = 0; + + /* "analysis.py":513 + * def z_score(point, mean, stdev): + * score = (point - mean) / stdev + * return score # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_score); + __pyx_r = __pyx_v_score; + goto __pyx_L0; + + /* "analysis.py":511 + * + * # returns z score with inputs of point, mean and standard deviation of spread + * def z_score(point, mean, stdev): # <<<<<<<<<<<<<< + * score = (point - mean) / stdev + * return score + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("analysis.z_score", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_score); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":517 + * + * # mode is either 'x' or 'y' or 'both' depending on the variable(s) to be normalized + * def z_normalize(x, y, mode): # <<<<<<<<<<<<<< + * + * x_norm = [] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_9z_normalize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_9z_normalize = {"z_normalize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_9z_normalize, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_9z_normalize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_x = 0; + PyObject *__pyx_v_y = 0; + PyObject *__pyx_v_mode = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("z_normalize (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_mode,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_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("z_normalize", 1, 3, 3, 1); __PYX_ERR(0, 517, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("z_normalize", 1, 3, 3, 2); __PYX_ERR(0, 517, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "z_normalize") < 0)) __PYX_ERR(0, 517, __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_x = values[0]; + __pyx_v_y = values[1]; + __pyx_v_mode = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("z_normalize", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 517, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.z_normalize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_8z_normalize(__pyx_self, __pyx_v_x, __pyx_v_y, __pyx_v_mode); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_8z_normalize(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y, PyObject *__pyx_v_mode) { + PyObject *__pyx_v_x_norm = NULL; + PyObject *__pyx_v_y_norm = NULL; + CYTHON_UNUSED long __pyx_v_mean; + CYTHON_UNUSED long __pyx_v_stdev; + PyObject *__pyx_v__mean = NULL; + CYTHON_UNUSED PyObject *__pyx_v__median = NULL; + CYTHON_UNUSED PyObject *__pyx_v__mode = NULL; + PyObject *__pyx_v__stdev = NULL; + CYTHON_UNUSED PyObject *__pyx_v__variance = NULL; + Py_ssize_t __pyx_v_i; + 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_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *(*__pyx_t_10)(PyObject *); + Py_ssize_t __pyx_t_11; + Py_ssize_t __pyx_t_12; + Py_ssize_t __pyx_t_13; + int __pyx_t_14; + __Pyx_RefNannySetupContext("z_normalize", 0); + + /* "analysis.py":519 + * def z_normalize(x, y, mode): + * + * x_norm = [] # <<<<<<<<<<<<<< + * y_norm = [] + * + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_x_norm = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":520 + * + * x_norm = [] + * y_norm = [] # <<<<<<<<<<<<<< + * + * mean = 0 + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_y_norm = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":522 + * y_norm = [] + * + * mean = 0 # <<<<<<<<<<<<<< + * stdev = 0 + * + */ + __pyx_v_mean = 0; + + /* "analysis.py":523 + * + * mean = 0 + * stdev = 0 # <<<<<<<<<<<<<< + * + * if mode == 'x': + */ + __pyx_v_stdev = 0; + + /* "analysis.py":525 + * stdev = 0 + * + * if mode == 'x': # <<<<<<<<<<<<<< + * _mean, _median, _mode, _stdev, _variance = basic_stats(x, "1d", 0) + * + */ + __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_x, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 525, __pyx_L1_error) + if (__pyx_t_2) { + + /* "analysis.py":526 + * + * if mode == 'x': + * _mean, _median, _mode, _stdev, _variance = basic_stats(x, "1d", 0) # <<<<<<<<<<<<<< + * + * for i in range(0, len(x), 1): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_basic_stats); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + 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_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_x, __pyx_kp_s_1d, __pyx_int_0}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 526, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_x, __pyx_kp_s_1d, __pyx_int_0}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 526, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_6 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(__pyx_v_x); + __Pyx_GIVEREF(__pyx_v_x); + PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_v_x); + __Pyx_INCREF(__pyx_kp_s_1d); + __Pyx_GIVEREF(__pyx_kp_s_1d); + PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_kp_s_1d); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, __pyx_int_0); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 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 != 5)) { + if (size > 5) __Pyx_RaiseTooManyValuesError(5); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 526, __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_6 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 3); + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 4); + } else { + __pyx_t_3 = PyList_GET_ITEM(sequence, 0); + __pyx_t_6 = PyList_GET_ITEM(sequence, 1); + __pyx_t_4 = PyList_GET_ITEM(sequence, 2); + __pyx_t_7 = PyList_GET_ITEM(sequence, 3); + __pyx_t_8 = PyList_GET_ITEM(sequence, 4); + } + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + #else + { + Py_ssize_t i; + PyObject** temps[5] = {&__pyx_t_3,&__pyx_t_6,&__pyx_t_4,&__pyx_t_7,&__pyx_t_8}; + for (i=0; i < 5; i++) { + PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 526, __pyx_L1_error) + __Pyx_GOTREF(item); + *(temps[i]) = item; + } + } + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + PyObject** temps[5] = {&__pyx_t_3,&__pyx_t_6,&__pyx_t_4,&__pyx_t_7,&__pyx_t_8}; + __pyx_t_9 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; + for (index=0; index < 5; index++) { + PyObject* item = __pyx_t_10(__pyx_t_9); if (unlikely(!item)) goto __pyx_L4_unpacking_failed; + __Pyx_GOTREF(item); + *(temps[index]) = item; + } + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 5) < 0) __PYX_ERR(0, 526, __pyx_L1_error) + __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L5_unpacking_done; + __pyx_L4_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 526, __pyx_L1_error) + __pyx_L5_unpacking_done:; + } + __pyx_v__mean = __pyx_t_3; + __pyx_t_3 = 0; + __pyx_v__median = __pyx_t_6; + __pyx_t_6 = 0; + __pyx_v__mode = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_v__stdev = __pyx_t_7; + __pyx_t_7 = 0; + __pyx_v__variance = __pyx_t_8; + __pyx_t_8 = 0; + + /* "analysis.py":528 + * _mean, _median, _mode, _stdev, _variance = basic_stats(x, "1d", 0) + * + * for i in range(0, len(x), 1): # <<<<<<<<<<<<<< + * x_norm.append(z_score(x[i], _mean, _stdev)) + * + */ + __pyx_t_11 = PyObject_Length(__pyx_v_x); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(0, 528, __pyx_L1_error) + __pyx_t_12 = __pyx_t_11; + for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { + __pyx_v_i = __pyx_t_13; + + /* "analysis.py":529 + * + * for i in range(0, len(x), 1): + * x_norm.append(z_score(x[i], _mean, _stdev)) # <<<<<<<<<<<<<< + * + * return x_norm, y + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_z_score); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_x, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_t_7, __pyx_v__mean, __pyx_v__stdev}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_t_7, __pyx_v__mean, __pyx_v__stdev}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_t_7); + __Pyx_INCREF(__pyx_v__mean); + __Pyx_GIVEREF(__pyx_v__mean); + PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v__mean); + __Pyx_INCREF(__pyx_v__stdev); + __Pyx_GIVEREF(__pyx_v__stdev); + PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, __pyx_v__stdev); + __pyx_t_7 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_x_norm, __pyx_t_1); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "analysis.py":531 + * x_norm.append(z_score(x[i], _mean, _stdev)) + * + * return x_norm, y # <<<<<<<<<<<<<< + * + * if mode == 'y': + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 531, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_x_norm); + __Pyx_GIVEREF(__pyx_v_x_norm); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_x_norm); + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_y); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "analysis.py":525 + * stdev = 0 + * + * if mode == 'x': # <<<<<<<<<<<<<< + * _mean, _median, _mode, _stdev, _variance = basic_stats(x, "1d", 0) + * + */ + } + + /* "analysis.py":533 + * return x_norm, y + * + * if mode == 'y': # <<<<<<<<<<<<<< + * _mean, _median, _mode, _stdev, _variance = basic_stats(y, "1d", 0) + * + */ + __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_y, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 533, __pyx_L1_error) + if (__pyx_t_2) { + + /* "analysis.py":534 + * + * if mode == 'y': + * _mean, _median, _mode, _stdev, _variance = basic_stats(y, "1d", 0) # <<<<<<<<<<<<<< + * + * for i in range(0, len(y), 1): + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_basic_stats); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = NULL; + __pyx_t_5 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_v_y, __pyx_kp_s_1d, __pyx_int_0}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_v_y, __pyx_kp_s_1d, __pyx_int_0}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_7 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_5, __pyx_v_y); + __Pyx_INCREF(__pyx_kp_s_1d); + __Pyx_GIVEREF(__pyx_kp_s_1d); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_5, __pyx_kp_s_1d); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_5, __pyx_int_0); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 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 != 5)) { + if (size > 5) __Pyx_RaiseTooManyValuesError(5); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 534, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 2); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 3); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 4); + } else { + __pyx_t_8 = PyList_GET_ITEM(sequence, 0); + __pyx_t_7 = PyList_GET_ITEM(sequence, 1); + __pyx_t_6 = PyList_GET_ITEM(sequence, 2); + __pyx_t_4 = PyList_GET_ITEM(sequence, 3); + __pyx_t_3 = PyList_GET_ITEM(sequence, 4); + } + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + #else + { + Py_ssize_t i; + PyObject** temps[5] = {&__pyx_t_8,&__pyx_t_7,&__pyx_t_6,&__pyx_t_4,&__pyx_t_3}; + for (i=0; i < 5; i++) { + PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_GOTREF(item); + *(temps[i]) = item; + } + } + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + PyObject** temps[5] = {&__pyx_t_8,&__pyx_t_7,&__pyx_t_6,&__pyx_t_4,&__pyx_t_3}; + __pyx_t_9 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; + for (index=0; index < 5; index++) { + PyObject* item = __pyx_t_10(__pyx_t_9); if (unlikely(!item)) goto __pyx_L9_unpacking_failed; + __Pyx_GOTREF(item); + *(temps[index]) = item; + } + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 5) < 0) __PYX_ERR(0, 534, __pyx_L1_error) + __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L10_unpacking_done; + __pyx_L9_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 534, __pyx_L1_error) + __pyx_L10_unpacking_done:; + } + __pyx_v__mean = __pyx_t_8; + __pyx_t_8 = 0; + __pyx_v__median = __pyx_t_7; + __pyx_t_7 = 0; + __pyx_v__mode = __pyx_t_6; + __pyx_t_6 = 0; + __pyx_v__stdev = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_v__variance = __pyx_t_3; + __pyx_t_3 = 0; + + /* "analysis.py":536 + * _mean, _median, _mode, _stdev, _variance = basic_stats(y, "1d", 0) + * + * for i in range(0, len(y), 1): # <<<<<<<<<<<<<< + * y_norm.append(z_score(y[i], _mean, _stdev)) + * + */ + __pyx_t_11 = PyObject_Length(__pyx_v_y); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(0, 536, __pyx_L1_error) + __pyx_t_12 = __pyx_t_11; + for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { + __pyx_v_i = __pyx_t_13; + + /* "analysis.py":537 + * + * for i in range(0, len(y), 1): + * y_norm.append(z_score(y[i], _mean, _stdev)) # <<<<<<<<<<<<<< + * + * return x, y_norm + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_z_score); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_y, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = NULL; + __pyx_t_5 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_t_4, __pyx_v__mean, __pyx_v__stdev}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_t_4, __pyx_v__mean, __pyx_v__stdev}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_5, __pyx_t_4); + __Pyx_INCREF(__pyx_v__mean); + __Pyx_GIVEREF(__pyx_v__mean); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_5, __pyx_v__mean); + __Pyx_INCREF(__pyx_v__stdev); + __Pyx_GIVEREF(__pyx_v__stdev); + PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_5, __pyx_v__stdev); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_y_norm, __pyx_t_1); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "analysis.py":539 + * y_norm.append(z_score(y[i], _mean, _stdev)) + * + * return x, y_norm # <<<<<<<<<<<<<< + * + * if mode == 'both': + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 539, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_x); + __Pyx_GIVEREF(__pyx_v_x); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_x); + __Pyx_INCREF(__pyx_v_y_norm); + __Pyx_GIVEREF(__pyx_v_y_norm); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_y_norm); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "analysis.py":533 + * return x_norm, y + * + * if mode == 'y': # <<<<<<<<<<<<<< + * _mean, _median, _mode, _stdev, _variance = basic_stats(y, "1d", 0) + * + */ + } + + /* "analysis.py":541 + * return x, y_norm + * + * if mode == 'both': # <<<<<<<<<<<<<< + * _mean, _median, _mode, _stdev, _variance = basic_stats(x, "1d", 0) + * + */ + __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_both, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 541, __pyx_L1_error) + if (__pyx_t_2) { + + /* "analysis.py":542 + * + * if mode == 'both': + * _mean, _median, _mode, _stdev, _variance = basic_stats(x, "1d", 0) # <<<<<<<<<<<<<< + * + * for i in range(0, len(x), 1): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_basic_stats); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 542, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_5 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_x, __pyx_kp_s_1d, __pyx_int_0}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 542, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_x, __pyx_kp_s_1d, __pyx_int_0}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 542, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 542, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_INCREF(__pyx_v_x); + __Pyx_GIVEREF(__pyx_v_x); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_5, __pyx_v_x); + __Pyx_INCREF(__pyx_kp_s_1d); + __Pyx_GIVEREF(__pyx_kp_s_1d); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_5, __pyx_kp_s_1d); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_5, __pyx_int_0); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 542, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 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 != 5)) { + if (size > 5) __Pyx_RaiseTooManyValuesError(5); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 542, __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); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 2); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 3); + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 4); + } else { + __pyx_t_3 = PyList_GET_ITEM(sequence, 0); + __pyx_t_4 = PyList_GET_ITEM(sequence, 1); + __pyx_t_7 = PyList_GET_ITEM(sequence, 2); + __pyx_t_6 = PyList_GET_ITEM(sequence, 3); + __pyx_t_8 = PyList_GET_ITEM(sequence, 4); + } + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + #else + { + Py_ssize_t i; + PyObject** temps[5] = {&__pyx_t_3,&__pyx_t_4,&__pyx_t_7,&__pyx_t_6,&__pyx_t_8}; + for (i=0; i < 5; i++) { + PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 542, __pyx_L1_error) + __Pyx_GOTREF(item); + *(temps[i]) = item; + } + } + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + PyObject** temps[5] = {&__pyx_t_3,&__pyx_t_4,&__pyx_t_7,&__pyx_t_6,&__pyx_t_8}; + __pyx_t_9 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 542, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; + for (index=0; index < 5; index++) { + PyObject* item = __pyx_t_10(__pyx_t_9); if (unlikely(!item)) goto __pyx_L14_unpacking_failed; + __Pyx_GOTREF(item); + *(temps[index]) = item; + } + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 5) < 0) __PYX_ERR(0, 542, __pyx_L1_error) + __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L15_unpacking_done; + __pyx_L14_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 542, __pyx_L1_error) + __pyx_L15_unpacking_done:; + } + __pyx_v__mean = __pyx_t_3; + __pyx_t_3 = 0; + __pyx_v__median = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_v__mode = __pyx_t_7; + __pyx_t_7 = 0; + __pyx_v__stdev = __pyx_t_6; + __pyx_t_6 = 0; + __pyx_v__variance = __pyx_t_8; + __pyx_t_8 = 0; + + /* "analysis.py":544 + * _mean, _median, _mode, _stdev, _variance = basic_stats(x, "1d", 0) + * + * for i in range(0, len(x), 1): # <<<<<<<<<<<<<< + * x_norm.append(z_score(x[i], _mean, _stdev)) + * + */ + __pyx_t_11 = PyObject_Length(__pyx_v_x); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(0, 544, __pyx_L1_error) + __pyx_t_12 = __pyx_t_11; + for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { + __pyx_v_i = __pyx_t_13; + + /* "analysis.py":545 + * + * for i in range(0, len(x), 1): + * x_norm.append(z_score(x[i], _mean, _stdev)) # <<<<<<<<<<<<<< + * + * _mean, _median, _mode, _stdev, _variance = basic_stats(y, "1d", 0) + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_z_score); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_x, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_5 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_6, __pyx_v__mean, __pyx_v__stdev}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 545, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_6, __pyx_v__mean, __pyx_v__stdev}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 545, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_5, __pyx_t_6); + __Pyx_INCREF(__pyx_v__mean); + __Pyx_GIVEREF(__pyx_v__mean); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_5, __pyx_v__mean); + __Pyx_INCREF(__pyx_v__stdev); + __Pyx_GIVEREF(__pyx_v__stdev); + PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_5, __pyx_v__stdev); + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_x_norm, __pyx_t_1); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(0, 545, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "analysis.py":547 + * x_norm.append(z_score(x[i], _mean, _stdev)) + * + * _mean, _median, _mode, _stdev, _variance = basic_stats(y, "1d", 0) # <<<<<<<<<<<<<< + * + * for i in range(0, len(y), 1): + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_basic_stats); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_y, __pyx_kp_s_1d, __pyx_int_0}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_y, __pyx_kp_s_1d, __pyx_int_0}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_6 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_v_y); + __Pyx_INCREF(__pyx_kp_s_1d); + __Pyx_GIVEREF(__pyx_kp_s_1d); + PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_kp_s_1d); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, __pyx_int_0); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 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 != 5)) { + if (size > 5) __Pyx_RaiseTooManyValuesError(5); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 547, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 3); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 4); + } else { + __pyx_t_8 = PyList_GET_ITEM(sequence, 0); + __pyx_t_6 = PyList_GET_ITEM(sequence, 1); + __pyx_t_4 = PyList_GET_ITEM(sequence, 2); + __pyx_t_7 = PyList_GET_ITEM(sequence, 3); + __pyx_t_3 = PyList_GET_ITEM(sequence, 4); + } + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); + #else + { + Py_ssize_t i; + PyObject** temps[5] = {&__pyx_t_8,&__pyx_t_6,&__pyx_t_4,&__pyx_t_7,&__pyx_t_3}; + for (i=0; i < 5; i++) { + PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_GOTREF(item); + *(temps[i]) = item; + } + } + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + PyObject** temps[5] = {&__pyx_t_8,&__pyx_t_6,&__pyx_t_4,&__pyx_t_7,&__pyx_t_3}; + __pyx_t_9 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; + for (index=0; index < 5; index++) { + PyObject* item = __pyx_t_10(__pyx_t_9); if (unlikely(!item)) goto __pyx_L18_unpacking_failed; + __Pyx_GOTREF(item); + *(temps[index]) = item; + } + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 5) < 0) __PYX_ERR(0, 547, __pyx_L1_error) + __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L19_unpacking_done; + __pyx_L18_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 547, __pyx_L1_error) + __pyx_L19_unpacking_done:; + } + __Pyx_DECREF_SET(__pyx_v__mean, __pyx_t_8); + __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v__median, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_DECREF_SET(__pyx_v__mode, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v__stdev, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_DECREF_SET(__pyx_v__variance, __pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":549 + * _mean, _median, _mode, _stdev, _variance = basic_stats(y, "1d", 0) + * + * for i in range(0, len(y), 1): # <<<<<<<<<<<<<< + * y_norm.append(z_score(y[i], _mean, _stdev)) + * + */ + __pyx_t_11 = PyObject_Length(__pyx_v_y); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(0, 549, __pyx_L1_error) + __pyx_t_12 = __pyx_t_11; + for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { + __pyx_v_i = __pyx_t_13; + + /* "analysis.py":550 + * + * for i in range(0, len(y), 1): + * y_norm.append(z_score(y[i], _mean, _stdev)) # <<<<<<<<<<<<<< + * + * return x_norm, y_norm + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_z_score); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_y, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + 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_5 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_t_7, __pyx_v__mean, __pyx_v__stdev}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 550, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_t_7, __pyx_v__mean, __pyx_v__stdev}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 550, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_t_7); + __Pyx_INCREF(__pyx_v__mean); + __Pyx_GIVEREF(__pyx_v__mean); + PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v__mean); + __Pyx_INCREF(__pyx_v__stdev); + __Pyx_GIVEREF(__pyx_v__stdev); + PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, __pyx_v__stdev); + __pyx_t_7 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_y_norm, __pyx_t_1); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(0, 550, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "analysis.py":552 + * y_norm.append(z_score(y[i], _mean, _stdev)) + * + * return x_norm, y_norm # <<<<<<<<<<<<<< + * + * else: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 552, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_x_norm); + __Pyx_GIVEREF(__pyx_v_x_norm); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_x_norm); + __Pyx_INCREF(__pyx_v_y_norm); + __Pyx_GIVEREF(__pyx_v_y_norm); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_y_norm); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "analysis.py":541 + * return x, y_norm + * + * if mode == 'both': # <<<<<<<<<<<<<< + * _mean, _median, _mode, _stdev, _variance = basic_stats(x, "1d", 0) + * + */ + } + + /* "analysis.py":556 + * else: + * + * return error('method error') # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_6, __pyx_kp_s_method_error) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_s_method_error); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + } + + /* "analysis.py":517 + * + * # mode is either 'x' or 'y' or 'both' depending on the variable(s) to be normalized + * def z_normalize(x, y, mode): # <<<<<<<<<<<<<< + * + * x_norm = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("analysis.z_normalize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_x_norm); + __Pyx_XDECREF(__pyx_v_y_norm); + __Pyx_XDECREF(__pyx_v__mean); + __Pyx_XDECREF(__pyx_v__median); + __Pyx_XDECREF(__pyx_v__mode); + __Pyx_XDECREF(__pyx_v__stdev); + __Pyx_XDECREF(__pyx_v__variance); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":560 + * + * # returns n-th percentile of spread given mean, standard deviation, lower z-score, and upper z-score + * def stdev_z_split(mean, stdev, delta, low_bound, high_bound): # <<<<<<<<<<<<<< + * + * z_split = [] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_11stdev_z_split(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_11stdev_z_split = {"stdev_z_split", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_11stdev_z_split, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_11stdev_z_split(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_mean = 0; + PyObject *__pyx_v_stdev = 0; + PyObject *__pyx_v_delta = 0; + PyObject *__pyx_v_low_bound = 0; + PyObject *__pyx_v_high_bound = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stdev_z_split (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_mean,&__pyx_n_s_stdev,&__pyx_n_s_delta,&__pyx_n_s_low_bound,&__pyx_n_s_high_bound,0}; + PyObject* values[5] = {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 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_mean)) != 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_stdev)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("stdev_z_split", 1, 5, 5, 1); __PYX_ERR(0, 560, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("stdev_z_split", 1, 5, 5, 2); __PYX_ERR(0, 560, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low_bound)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("stdev_z_split", 1, 5, 5, 3); __PYX_ERR(0, 560, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high_bound)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("stdev_z_split", 1, 5, 5, 4); __PYX_ERR(0, 560, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stdev_z_split") < 0)) __PYX_ERR(0, 560, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { + 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); + } + __pyx_v_mean = values[0]; + __pyx_v_stdev = values[1]; + __pyx_v_delta = values[2]; + __pyx_v_low_bound = values[3]; + __pyx_v_high_bound = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("stdev_z_split", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 560, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.stdev_z_split", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_10stdev_z_split(__pyx_self, __pyx_v_mean, __pyx_v_stdev, __pyx_v_delta, __pyx_v_low_bound, __pyx_v_high_bound); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_10stdev_z_split(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_mean, PyObject *__pyx_v_stdev, PyObject *__pyx_v_delta, PyObject *__pyx_v_low_bound, PyObject *__pyx_v_high_bound) { + PyObject *__pyx_v_z_split = NULL; + PyObject *__pyx_v_i = 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; + int __pyx_t_5; + int __pyx_t_6; + __Pyx_RefNannySetupContext("stdev_z_split", 0); + + /* "analysis.py":562 + * def stdev_z_split(mean, stdev, delta, low_bound, high_bound): + * + * z_split = [] # <<<<<<<<<<<<<< + * i = low_bound + * + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 562, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_z_split = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":563 + * + * z_split = [] + * i = low_bound # <<<<<<<<<<<<<< + * + * while True: + */ + __Pyx_INCREF(__pyx_v_low_bound); + __pyx_v_i = __pyx_v_low_bound; + + /* "analysis.py":565 + * i = low_bound + * + * while True: # <<<<<<<<<<<<<< + * z_split.append(float((1 / (stdev * math.sqrt(2 * math.pi))) * + * math.e ** (-0.5 * (((i - mean) / stdev) ** 2)))) + */ + while (1) { + + /* "analysis.py":566 + * + * while True: + * z_split.append(float((1 / (stdev * math.sqrt(2 * math.pi))) * # <<<<<<<<<<<<<< + * math.e ** (-0.5 * (((i - mean) / stdev) ** 2)))) + * i = i + delta + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_math); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_math); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_pi); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Multiply(__pyx_int_2, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __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_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Multiply(__pyx_v_stdev, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_int_1, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "analysis.py":567 + * while True: + * z_split.append(float((1 / (stdev * math.sqrt(2 * math.pi))) * + * math.e ** (-0.5 * (((i - mean) / stdev) ** 2)))) # <<<<<<<<<<<<<< + * i = i + delta + * if i > high_bound: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_math); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_e); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Subtract(__pyx_v_i, __pyx_v_mean); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_v_stdev); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Power(__pyx_t_4, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Multiply(__pyx_float_neg_0_5, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Power(__pyx_t_2, __pyx_t_4, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "analysis.py":566 + * + * while True: + * z_split.append(float((1 / (stdev * math.sqrt(2 * math.pi))) * # <<<<<<<<<<<<<< + * math.e ** (-0.5 * (((i - mean) / stdev) ** 2)))) + * i = i + delta + */ + __pyx_t_4 = PyNumber_Multiply(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyNumber_Float(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_z_split, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "analysis.py":568 + * z_split.append(float((1 / (stdev * math.sqrt(2 * math.pi))) * + * math.e ** (-0.5 * (((i - mean) / stdev) ** 2)))) + * i = i + delta # <<<<<<<<<<<<<< + * if i > high_bound: + * break + */ + __pyx_t_3 = PyNumber_Add(__pyx_v_i, __pyx_v_delta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_i, __pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":569 + * math.e ** (-0.5 * (((i - mean) / stdev) ** 2)))) + * i = i + delta + * if i > high_bound: # <<<<<<<<<<<<<< + * break + * + */ + __pyx_t_3 = PyObject_RichCompare(__pyx_v_i, __pyx_v_high_bound, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 569, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 569, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + + /* "analysis.py":570 + * i = i + delta + * if i > high_bound: + * break # <<<<<<<<<<<<<< + * + * return z_split + */ + goto __pyx_L4_break; + + /* "analysis.py":569 + * math.e ** (-0.5 * (((i - mean) / stdev) ** 2)))) + * i = i + delta + * if i > high_bound: # <<<<<<<<<<<<<< + * break + * + */ + } + } + __pyx_L4_break:; + + /* "analysis.py":572 + * break + * + * return z_split # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_z_split); + __pyx_r = __pyx_v_z_split; + goto __pyx_L0; + + /* "analysis.py":560 + * + * # returns n-th percentile of spread given mean, standard deviation, lower z-score, and upper z-score + * def stdev_z_split(mean, stdev, delta, low_bound, high_bound): # <<<<<<<<<<<<<< + * + * z_split = [] + */ + + /* 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("analysis.stdev_z_split", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_z_split); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":575 + * + * + * def histo_analysis(hist_data, delta, low_bound, high_bound): # <<<<<<<<<<<<<< + * + * if hist_data == 'debug': + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_13histo_analysis(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_13histo_analysis = {"histo_analysis", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_13histo_analysis, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_13histo_analysis(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_hist_data = 0; + PyObject *__pyx_v_delta = 0; + PyObject *__pyx_v_low_bound = 0; + PyObject *__pyx_v_high_bound = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("histo_analysis (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_hist_data,&__pyx_n_s_delta,&__pyx_n_s_low_bound,&__pyx_n_s_high_bound,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_hist_data)) != 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_delta)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("histo_analysis", 1, 4, 4, 1); __PYX_ERR(0, 575, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low_bound)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("histo_analysis", 1, 4, 4, 2); __PYX_ERR(0, 575, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high_bound)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("histo_analysis", 1, 4, 4, 3); __PYX_ERR(0, 575, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "histo_analysis") < 0)) __PYX_ERR(0, 575, __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_hist_data = values[0]; + __pyx_v_delta = values[1]; + __pyx_v_low_bound = values[2]; + __pyx_v_high_bound = values[3]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("histo_analysis", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 575, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.histo_analysis", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_12histo_analysis(__pyx_self, __pyx_v_hist_data, __pyx_v_delta, __pyx_v_low_bound, __pyx_v_high_bound); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_12histo_analysis(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_hist_data, PyObject *__pyx_v_delta, PyObject *__pyx_v_low_bound, PyObject *__pyx_v_high_bound) { + PyObject *__pyx_v_derivative = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_derivative_sorted = NULL; + PyObject *__pyx_v_mean_derivative = NULL; + PyObject *__pyx_v_stdev_derivative = NULL; + PyObject *__pyx_v_predictions = NULL; + PyObject *__pyx_v_pred_change = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + 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; + double __pyx_t_10; + double __pyx_t_11; + int __pyx_t_12; + int __pyx_t_13; + PyObject *__pyx_t_14 = NULL; + __Pyx_RefNannySetupContext("histo_analysis", 0); + + /* "analysis.py":577 + * def histo_analysis(hist_data, delta, low_bound, high_bound): + * + * if hist_data == 'debug': # <<<<<<<<<<<<<< + * return ('returns list of predicted values based on historical data; input delta for delta step in z-score and lower and higher bounds in number of standard deviations') + * + */ + __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_hist_data, __pyx_n_s_debug, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 577, __pyx_L1_error) + if (__pyx_t_1) { + + /* "analysis.py":578 + * + * if hist_data == 'debug': + * return ('returns list of predicted values based on historical data; input delta for delta step in z-score and lower and higher bounds in number of standard deviations') # <<<<<<<<<<<<<< + * + * derivative = [] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_kp_s_returns_list_of_predicted_values); + __pyx_r = __pyx_kp_s_returns_list_of_predicted_values; + goto __pyx_L0; + + /* "analysis.py":577 + * def histo_analysis(hist_data, delta, low_bound, high_bound): + * + * if hist_data == 'debug': # <<<<<<<<<<<<<< + * return ('returns list of predicted values based on historical data; input delta for delta step in z-score and lower and higher bounds in number of standard deviations') + * + */ + } + + /* "analysis.py":580 + * return ('returns list of predicted values based on historical data; input delta for delta step in z-score and lower and higher bounds in number of standard deviations') + * + * derivative = [] # <<<<<<<<<<<<<< + * + * for i in range(0, len(hist_data), 1): + */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 580, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_derivative = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":582 + * derivative = [] + * + * for i in range(0, len(hist_data), 1): # <<<<<<<<<<<<<< + * try: + * derivative.append(float(hist_data[i - 1]) - float(hist_data[i])) + */ + __pyx_t_3 = PyObject_Length(__pyx_v_hist_data); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 582, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 582, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 582, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_int_1); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 582, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_4 = __pyx_t_2; __Pyx_INCREF(__pyx_t_4); __pyx_t_3 = 0; + __pyx_t_5 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 582, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 582, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_5)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 582, __pyx_L1_error) + #else + __pyx_t_2 = PySequence_ITEM(__pyx_t_4, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 582, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 582, __pyx_L1_error) + #else + __pyx_t_2 = PySequence_ITEM(__pyx_t_4, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 582, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_5(__pyx_t_4); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 582, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":583 + * + * for i in range(0, len(hist_data), 1): + * try: # <<<<<<<<<<<<<< + * derivative.append(float(hist_data[i - 1]) - float(hist_data[i])) + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + /*try:*/ { + + /* "analysis.py":584 + * for i in range(0, len(hist_data), 1): + * try: + * derivative.append(float(hist_data[i - 1]) - float(hist_data[i])) # <<<<<<<<<<<<<< + * except: + * pass + */ + __pyx_t_2 = __Pyx_PyInt_SubtractObjC(__pyx_v_i, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 584, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_PyObject_GetItem(__pyx_v_hist_data, __pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 584, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = __Pyx_PyObject_AsDouble(__pyx_t_9); if (unlikely(__pyx_t_10 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 584, __pyx_L6_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_GetItem(__pyx_v_hist_data, __pyx_v_i); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 584, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_11 = __Pyx_PyObject_AsDouble(__pyx_t_9); if (unlikely(__pyx_t_11 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 584, __pyx_L6_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PyFloat_FromDouble((__pyx_t_10 - __pyx_t_11)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 584, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_derivative, __pyx_t_9); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 584, __pyx_L6_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":583 + * + * for i in range(0, len(hist_data), 1): + * try: # <<<<<<<<<<<<<< + * derivative.append(float(hist_data[i - 1]) - float(hist_data[i])) + * except: + */ + } + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L13_try_end; + __pyx_L6_error:; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":585 + * try: + * derivative.append(float(hist_data[i - 1]) - float(hist_data[i])) + * except: # <<<<<<<<<<<<<< + * pass + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L7_exception_handled; + } + __pyx_L7_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + __pyx_L13_try_end:; + } + + /* "analysis.py":582 + * derivative = [] + * + * for i in range(0, len(hist_data), 1): # <<<<<<<<<<<<<< + * try: + * derivative.append(float(hist_data[i - 1]) - float(hist_data[i])) + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "analysis.py":588 + * pass + * + * derivative_sorted = sorted(derivative, key=int) # <<<<<<<<<<<<<< + * mean_derivative = basic_stats(derivative_sorted, "1d", 0)[0] + * stdev_derivative = basic_stats(derivative_sorted, "1d", 0)[3] + */ + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 588, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_derivative); + __Pyx_GIVEREF(__pyx_v_derivative); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_derivative); + __pyx_t_9 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 588, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_key, ((PyObject *)(&PyInt_Type))) < 0) __PYX_ERR(0, 588, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_sorted, __pyx_t_4, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 588, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_derivative_sorted = __pyx_t_2; + __pyx_t_2 = 0; + + /* "analysis.py":589 + * + * derivative_sorted = sorted(derivative, key=int) + * mean_derivative = basic_stats(derivative_sorted, "1d", 0)[0] # <<<<<<<<<<<<<< + * stdev_derivative = basic_stats(derivative_sorted, "1d", 0)[3] + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_basic_stats); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = NULL; + __pyx_t_13 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_13 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_derivative_sorted, __pyx_kp_s_1d, __pyx_int_0}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_13, 3+__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_derivative_sorted, __pyx_kp_s_1d, __pyx_int_0}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_13, 3+__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_14 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(__pyx_v_derivative_sorted); + __Pyx_GIVEREF(__pyx_v_derivative_sorted); + PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_v_derivative_sorted); + __Pyx_INCREF(__pyx_kp_s_1d); + __Pyx_GIVEREF(__pyx_kp_s_1d); + PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_kp_s_1d); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_14, 2+__pyx_t_13, __pyx_int_0); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_14, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_mean_derivative = __pyx_t_9; + __pyx_t_9 = 0; + + /* "analysis.py":590 + * derivative_sorted = sorted(derivative, key=int) + * mean_derivative = basic_stats(derivative_sorted, "1d", 0)[0] + * stdev_derivative = basic_stats(derivative_sorted, "1d", 0)[3] # <<<<<<<<<<<<<< + * + * predictions = [] + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_basic_stats); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_14 = NULL; + __pyx_t_13 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_14)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_14); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_13 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[4] = {__pyx_t_14, __pyx_v_derivative_sorted, __pyx_kp_s_1d, __pyx_int_0}; + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_13, 3+__pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 590, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[4] = {__pyx_t_14, __pyx_v_derivative_sorted, __pyx_kp_s_1d, __pyx_int_0}; + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_13, 3+__pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 590, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else + #endif + { + __pyx_t_4 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_14) { + __Pyx_GIVEREF(__pyx_t_14); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_14); __pyx_t_14 = NULL; + } + __Pyx_INCREF(__pyx_v_derivative_sorted); + __Pyx_GIVEREF(__pyx_v_derivative_sorted); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_13, __pyx_v_derivative_sorted); + __Pyx_INCREF(__pyx_kp_s_1d); + __Pyx_GIVEREF(__pyx_kp_s_1d); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_13, __pyx_kp_s_1d); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_13, __pyx_int_0); + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_9, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_stdev_derivative = __pyx_t_2; + __pyx_t_2 = 0; + + /* "analysis.py":592 + * stdev_derivative = basic_stats(derivative_sorted, "1d", 0)[3] + * + * predictions = [] # <<<<<<<<<<<<<< + * pred_change = 0 + * + */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_predictions = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":593 + * + * predictions = [] + * pred_change = 0 # <<<<<<<<<<<<<< + * + * i = low_bound + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_v_pred_change = __pyx_int_0; + + /* "analysis.py":595 + * pred_change = 0 + * + * i = low_bound # <<<<<<<<<<<<<< + * + * while True: + */ + __Pyx_INCREF(__pyx_v_low_bound); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_v_low_bound); + + /* "analysis.py":597 + * i = low_bound + * + * while True: # <<<<<<<<<<<<<< + * if i > high_bound: + * break + */ + while (1) { + + /* "analysis.py":598 + * + * while True: + * if i > high_bound: # <<<<<<<<<<<<<< + * break + * + */ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_i, __pyx_v_high_bound, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 598, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 598, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "analysis.py":599 + * while True: + * if i > high_bound: + * break # <<<<<<<<<<<<<< + * + * try: + */ + goto __pyx_L15_break; + + /* "analysis.py":598 + * + * while True: + * if i > high_bound: # <<<<<<<<<<<<<< + * break + * + */ + } + + /* "analysis.py":601 + * break + * + * try: # <<<<<<<<<<<<<< + * pred_change = mean_derivative + i * stdev_derivative + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_6); + /*try:*/ { + + /* "analysis.py":602 + * + * try: + * pred_change = mean_derivative + i * stdev_derivative # <<<<<<<<<<<<<< + * except: + * pred_change = mean_derivative + */ + __pyx_t_2 = PyNumber_Multiply(__pyx_v_i, __pyx_v_stdev_derivative); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 602, __pyx_L17_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = PyNumber_Add(__pyx_v_mean_derivative, __pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 602, __pyx_L17_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_pred_change, __pyx_t_9); + __pyx_t_9 = 0; + + /* "analysis.py":601 + * break + * + * try: # <<<<<<<<<<<<<< + * pred_change = mean_derivative + i * stdev_derivative + * except: + */ + } + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L24_try_end; + __pyx_L17_error:; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":603 + * try: + * pred_change = mean_derivative + i * stdev_derivative + * except: # <<<<<<<<<<<<<< + * pred_change = mean_derivative + * + */ + /*except:*/ { + __Pyx_AddTraceback("analysis.histo_analysis", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_2, &__pyx_t_4) < 0) __PYX_ERR(0, 603, __pyx_L19_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_4); + + /* "analysis.py":604 + * pred_change = mean_derivative + i * stdev_derivative + * except: + * pred_change = mean_derivative # <<<<<<<<<<<<<< + * + * predictions.append(float(hist_data[-1:][0]) + pred_change) + */ + __Pyx_INCREF(__pyx_v_mean_derivative); + __Pyx_DECREF_SET(__pyx_v_pred_change, __pyx_v_mean_derivative); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L18_exception_handled; + } + __pyx_L19_except_error:; + + /* "analysis.py":601 + * break + * + * try: # <<<<<<<<<<<<<< + * pred_change = mean_derivative + i * stdev_derivative + * except: + */ + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_7, __pyx_t_6); + goto __pyx_L1_error; + __pyx_L18_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_7, __pyx_t_6); + __pyx_L24_try_end:; + } + + /* "analysis.py":606 + * pred_change = mean_derivative + * + * predictions.append(float(hist_data[-1:][0]) + pred_change) # <<<<<<<<<<<<<< + * + * i = i + delta + */ + __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_v_hist_data, -1L, 0, NULL, NULL, &__pyx_slice__4, 1, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyNumber_Float(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Add(__pyx_t_4, __pyx_v_pred_change); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_predictions, __pyx_t_2); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 606, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":608 + * predictions.append(float(hist_data[-1:][0]) + pred_change) + * + * i = i + delta # <<<<<<<<<<<<<< + * + * return predictions + */ + __pyx_t_2 = PyNumber_Add(__pyx_v_i, __pyx_v_delta); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 608, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_i, __pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L15_break:; + + /* "analysis.py":610 + * i = i + delta + * + * return predictions # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_predictions); + __pyx_r = __pyx_v_predictions; + goto __pyx_L0; + + /* "analysis.py":575 + * + * + * def histo_analysis(hist_data, delta, low_bound, high_bound): # <<<<<<<<<<<<<< + * + * if hist_data == 'debug': + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_AddTraceback("analysis.histo_analysis", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_derivative); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_derivative_sorted); + __Pyx_XDECREF(__pyx_v_mean_derivative); + __Pyx_XDECREF(__pyx_v_stdev_derivative); + __Pyx_XDECREF(__pyx_v_predictions); + __Pyx_XDECREF(__pyx_v_pred_change); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":613 + * + * + * def poly_regression(x, y, power): # <<<<<<<<<<<<<< + * + * if x == "null": # if x is 'null', then x will be filled with integer points between 1 and the size of y + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_15poly_regression(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_15poly_regression = {"poly_regression", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_15poly_regression, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_15poly_regression(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_x = 0; + PyObject *__pyx_v_y = 0; + PyObject *__pyx_v_power = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("poly_regression (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_power,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_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("poly_regression", 1, 3, 3, 1); __PYX_ERR(0, 613, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_power)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("poly_regression", 1, 3, 3, 2); __PYX_ERR(0, 613, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "poly_regression") < 0)) __PYX_ERR(0, 613, __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_x = values[0]; + __pyx_v_y = values[1]; + __pyx_v_power = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("poly_regression", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 613, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.poly_regression", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_14poly_regression(__pyx_self, __pyx_v_x, __pyx_v_y, __pyx_v_power); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_14poly_regression(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y, PyObject *__pyx_v_power) { + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_reg_eq = NULL; + PyObject *__pyx_v_eq_str = NULL; + PyObject *__pyx_v_vals = NULL; + PyObject *__pyx_v_z = NULL; + PyObject *__pyx_v__rms = NULL; + PyObject *__pyx_v_r2_d2 = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *(*__pyx_t_5)(PyObject *); + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + int __pyx_t_14; + __Pyx_RefNannySetupContext("poly_regression", 0); + __Pyx_INCREF(__pyx_v_x); + + /* "analysis.py":615 + * def poly_regression(x, y, power): + * + * if x == "null": # if x is 'null', then x will be filled with integer points between 1 and the size of y # <<<<<<<<<<<<<< + * x = [] + * + */ + __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_x, __pyx_n_s_null, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 615, __pyx_L1_error) + if (__pyx_t_1) { + + /* "analysis.py":616 + * + * if x == "null": # if x is 'null', then x will be filled with integer points between 1 and the size of y + * x = [] # <<<<<<<<<<<<<< + * + * for i in range(len(y)): + */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_x, __pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":618 + * x = [] + * + * for i in range(len(y)): # <<<<<<<<<<<<<< + * print(i) + * x.append(i + 1) + */ + __pyx_t_3 = PyObject_Length(__pyx_v_y); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 618, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { + __pyx_t_2 = __pyx_t_4; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_5 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 618, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + for (;;) { + if (likely(!__pyx_t_5)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 618, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 618, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_5(__pyx_t_2); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 618, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_4); + __pyx_t_4 = 0; + + /* "analysis.py":619 + * + * for i in range(len(y)): + * print(i) # <<<<<<<<<<<<<< + * x.append(i + 1) + * + */ + if (__Pyx_PrintOne(0, __pyx_v_i) < 0) __PYX_ERR(0, 619, __pyx_L1_error) + + /* "analysis.py":620 + * for i in range(len(y)): + * print(i) + * x.append(i + 1) # <<<<<<<<<<<<<< + * + * reg_eq = scipy.polyfit(x, y, deg=power) + */ + __pyx_t_4 = __Pyx_PyInt_AddObjC(__pyx_v_i, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 620, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_Append(__pyx_v_x, __pyx_t_4); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 620, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "analysis.py":618 + * x = [] + * + * for i in range(len(y)): # <<<<<<<<<<<<<< + * print(i) + * x.append(i + 1) + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":615 + * def poly_regression(x, y, power): + * + * if x == "null": # if x is 'null', then x will be filled with integer points between 1 and the size of y # <<<<<<<<<<<<<< + * x = [] + * + */ + } + + /* "analysis.py":622 + * x.append(i + 1) + * + * reg_eq = scipy.polyfit(x, y, deg=power) # <<<<<<<<<<<<<< + * eq_str = "" + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_scipy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_polyfit); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_x); + __Pyx_GIVEREF(__pyx_v_x); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_x); + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_y); + __pyx_t_7 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_deg, __pyx_v_power) < 0) __PYX_ERR(0, 622, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_reg_eq = __pyx_t_8; + __pyx_t_8 = 0; + + /* "analysis.py":623 + * + * reg_eq = scipy.polyfit(x, y, deg=power) + * eq_str = "" # <<<<<<<<<<<<<< + * + * for i in range(0, len(reg_eq), 1): + */ + __Pyx_INCREF(__pyx_kp_s__2); + __pyx_v_eq_str = __pyx_kp_s__2; + + /* "analysis.py":625 + * eq_str = "" + * + * for i in range(0, len(reg_eq), 1): # <<<<<<<<<<<<<< + * if i < len(reg_eq) - 1: + * eq_str = eq_str + str(reg_eq[i]) + \ + */ + __pyx_t_3 = PyObject_Length(__pyx_v_reg_eq); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 625, __pyx_L1_error) + __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_int_1); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (likely(PyList_CheckExact(__pyx_t_8)) || PyTuple_CheckExact(__pyx_t_8)) { + __pyx_t_7 = __pyx_t_8; __Pyx_INCREF(__pyx_t_7); __pyx_t_3 = 0; + __pyx_t_5 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 625, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + for (;;) { + if (likely(!__pyx_t_5)) { + if (likely(PyList_CheckExact(__pyx_t_7))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_7)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_3); __Pyx_INCREF(__pyx_t_8); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 625, __pyx_L1_error) + #else + __pyx_t_8 = PySequence_ITEM(__pyx_t_7, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_7)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_3); __Pyx_INCREF(__pyx_t_8); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 625, __pyx_L1_error) + #else + __pyx_t_8 = PySequence_ITEM(__pyx_t_7, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } + } else { + __pyx_t_8 = __pyx_t_5(__pyx_t_7); + if (unlikely(!__pyx_t_8)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 625, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_8); + __pyx_t_8 = 0; + + /* "analysis.py":626 + * + * for i in range(0, len(reg_eq), 1): + * if i < len(reg_eq) - 1: # <<<<<<<<<<<<<< + * eq_str = eq_str + str(reg_eq[i]) + \ + * "*(z**" + str(len(reg_eq) - i - 1) + ")+" + */ + __pyx_t_9 = PyObject_Length(__pyx_v_reg_eq); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 626, __pyx_L1_error) + __pyx_t_8 = PyInt_FromSsize_t((__pyx_t_9 - 1)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 626, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = PyObject_RichCompare(__pyx_v_i, __pyx_t_8, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 626, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 626, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "analysis.py":627 + * for i in range(0, len(reg_eq), 1): + * if i < len(reg_eq) - 1: + * eq_str = eq_str + str(reg_eq[i]) + \ # <<<<<<<<<<<<<< + * "*(z**" + str(len(reg_eq) - i - 1) + ")+" + * else: + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_reg_eq, __pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 627, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 627, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Add(__pyx_v_eq_str, __pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 627, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(__pyx_t_2, __pyx_kp_s_z); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 627, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":628 + * if i < len(reg_eq) - 1: + * eq_str = eq_str + str(reg_eq[i]) + \ + * "*(z**" + str(len(reg_eq) - i - 1) + ")+" # <<<<<<<<<<<<<< + * else: + * eq_str = eq_str + str(reg_eq[i]) + \ + */ + __pyx_t_9 = PyObject_Length(__pyx_v_reg_eq); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 628, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyNumber_Subtract(__pyx_t_2, __pyx_v_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyInt_SubtractObjC(__pyx_t_4, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Add(__pyx_t_8, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Add(__pyx_t_2, __pyx_kp_s__5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_eq_str, __pyx_t_4); + __pyx_t_4 = 0; + + /* "analysis.py":626 + * + * for i in range(0, len(reg_eq), 1): + * if i < len(reg_eq) - 1: # <<<<<<<<<<<<<< + * eq_str = eq_str + str(reg_eq[i]) + \ + * "*(z**" + str(len(reg_eq) - i - 1) + ")+" + */ + goto __pyx_L8; + } + + /* "analysis.py":631 + * else: + * eq_str = eq_str + str(reg_eq[i]) + \ + * "*(z**" + str(len(reg_eq) - i - 1) + ")" # <<<<<<<<<<<<<< + * + * vals = [] + */ + /*else*/ { + + /* "analysis.py":630 + * "*(z**" + str(len(reg_eq) - i - 1) + ")+" + * else: + * eq_str = eq_str + str(reg_eq[i]) + \ # <<<<<<<<<<<<<< + * "*(z**" + str(len(reg_eq) - i - 1) + ")" + * + */ + __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_reg_eq, __pyx_v_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Add(__pyx_v_eq_str, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Add(__pyx_t_4, __pyx_kp_s_z); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "analysis.py":631 + * else: + * eq_str = eq_str + str(reg_eq[i]) + \ + * "*(z**" + str(len(reg_eq) - i - 1) + ")" # <<<<<<<<<<<<<< + * + * vals = [] + */ + __pyx_t_9 = PyObject_Length(__pyx_v_reg_eq); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 631, __pyx_L1_error) + __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = PyNumber_Subtract(__pyx_t_4, __pyx_v_i); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyInt_SubtractObjC(__pyx_t_8, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Add(__pyx_t_2, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(__pyx_t_4, __pyx_kp_s__6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_eq_str, __pyx_t_8); + __pyx_t_8 = 0; + } + __pyx_L8:; + + /* "analysis.py":625 + * eq_str = "" + * + * for i in range(0, len(reg_eq), 1): # <<<<<<<<<<<<<< + * if i < len(reg_eq) - 1: + * eq_str = eq_str + str(reg_eq[i]) + \ + */ + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "analysis.py":633 + * "*(z**" + str(len(reg_eq) - i - 1) + ")" + * + * vals = [] # <<<<<<<<<<<<<< + * + * for i in range(0, len(x), 1): + */ + __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 633, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_v_vals = ((PyObject*)__pyx_t_7); + __pyx_t_7 = 0; + + /* "analysis.py":635 + * vals = [] + * + * for i in range(0, len(x), 1): # <<<<<<<<<<<<<< + * z = x[i] + * + */ + __pyx_t_3 = PyObject_Length(__pyx_v_x); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 635, __pyx_L1_error) + __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_int_1); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (likely(PyList_CheckExact(__pyx_t_7)) || PyTuple_CheckExact(__pyx_t_7)) { + __pyx_t_8 = __pyx_t_7; __Pyx_INCREF(__pyx_t_8); __pyx_t_3 = 0; + __pyx_t_5 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = Py_TYPE(__pyx_t_8)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 635, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + for (;;) { + if (likely(!__pyx_t_5)) { + if (likely(PyList_CheckExact(__pyx_t_8))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_8)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_3); __Pyx_INCREF(__pyx_t_7); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 635, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_8, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_8)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_3); __Pyx_INCREF(__pyx_t_7); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 635, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_8, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } + } else { + __pyx_t_7 = __pyx_t_5(__pyx_t_8); + 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(0, 635, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_7); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_7); + __pyx_t_7 = 0; + + /* "analysis.py":636 + * + * for i in range(0, len(x), 1): + * z = x[i] # <<<<<<<<<<<<<< + * + * try: + */ + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_x, __pyx_v_i); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 636, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_v_z, __pyx_t_7); + __pyx_t_7 = 0; + + /* "analysis.py":638 + * z = x[i] + * + * try: # <<<<<<<<<<<<<< + * exec("vals.append(" + eq_str + ")") + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + /*try:*/ { + + /* "analysis.py":639 + * + * try: + * exec("vals.append(" + eq_str + ")") # <<<<<<<<<<<<<< + * except: + * pass + */ + __pyx_t_7 = PyNumber_Add(__pyx_kp_s_vals_append, __pyx_v_eq_str); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 639, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = PyNumber_Add(__pyx_t_7, __pyx_kp_s__6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 639, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_Globals(); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 639, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyDict_NewPresized(10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 639, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_v__rms) { + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rms, __pyx_v__rms) < 0) __PYX_ERR(0, 639, __pyx_L11_error) + } + if (__pyx_v_eq_str) { + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_eq_str, __pyx_v_eq_str) < 0) __PYX_ERR(0, 639, __pyx_L11_error) + } + if (__pyx_v_i) { + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_i, __pyx_v_i) < 0) __PYX_ERR(0, 639, __pyx_L11_error) + } + if (__pyx_v_power) { + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_power, __pyx_v_power) < 0) __PYX_ERR(0, 639, __pyx_L11_error) + } + if (__pyx_v_r2_d2) { + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_r2_d2, __pyx_v_r2_d2) < 0) __PYX_ERR(0, 639, __pyx_L11_error) + } + if (__pyx_v_reg_eq) { + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_reg_eq, __pyx_v_reg_eq) < 0) __PYX_ERR(0, 639, __pyx_L11_error) + } + if (__pyx_v_vals) { + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_vals, __pyx_v_vals) < 0) __PYX_ERR(0, 639, __pyx_L11_error) + } + if (__pyx_v_x) { + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_x, __pyx_v_x) < 0) __PYX_ERR(0, 639, __pyx_L11_error) + } + if (__pyx_v_y) { + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 639, __pyx_L11_error) + } + if (__pyx_v_z) { + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_z_2, __pyx_v_z) < 0) __PYX_ERR(0, 639, __pyx_L11_error) + } + __pyx_t_13 = __Pyx_PyExec3(__pyx_t_4, __pyx_t_7, __pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 639, __pyx_L11_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + + /* "analysis.py":638 + * z = x[i] + * + * try: # <<<<<<<<<<<<<< + * exec("vals.append(" + eq_str + ")") + * except: + */ + } + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + goto __pyx_L18_try_end; + __pyx_L11_error:; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "analysis.py":640 + * try: + * exec("vals.append(" + eq_str + ")") + * except: # <<<<<<<<<<<<<< + * pass + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L12_exception_handled; + } + __pyx_L12_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + __pyx_L18_try_end:; + } + + /* "analysis.py":635 + * vals = [] + * + * for i in range(0, len(x), 1): # <<<<<<<<<<<<<< + * z = x[i] + * + */ + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "analysis.py":643 + * pass + * + * _rms = rms(vals, y) # <<<<<<<<<<<<<< + * r2_d2 = r_squared(vals, y) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_n_s_rms_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_2 = NULL; + __pyx_t_14 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + __pyx_t_14 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_13)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_vals, __pyx_v_y}; + __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_13, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 643, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_8); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_13)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_vals, __pyx_v_y}; + __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_13, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 643, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_8); + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_INCREF(__pyx_v_vals); + __Pyx_GIVEREF(__pyx_v_vals); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_14, __pyx_v_vals); + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_14, __pyx_v_y); + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_v__rms = __pyx_t_8; + __pyx_t_8 = 0; + + /* "analysis.py":644 + * + * _rms = rms(vals, y) + * r2_d2 = r_squared(vals, y) # <<<<<<<<<<<<<< + * + * return [eq_str, _rms, r2_d2] + */ + __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_n_s_r_squared); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_7 = NULL; + __pyx_t_14 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + __pyx_t_14 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_13)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_vals, __pyx_v_y}; + __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_13, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 644, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_8); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_13)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_vals, __pyx_v_y}; + __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_13, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 644, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_8); + } else + #endif + { + __pyx_t_2 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_INCREF(__pyx_v_vals); + __Pyx_GIVEREF(__pyx_v_vals); + PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_14, __pyx_v_vals); + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_14, __pyx_v_y); + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_v_r2_d2 = __pyx_t_8; + __pyx_t_8 = 0; + + /* "analysis.py":646 + * r2_d2 = r_squared(vals, y) + * + * return [eq_str, _rms, r2_d2] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_8 = PyList_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 646, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_v_eq_str); + __Pyx_GIVEREF(__pyx_v_eq_str); + PyList_SET_ITEM(__pyx_t_8, 0, __pyx_v_eq_str); + __Pyx_INCREF(__pyx_v__rms); + __Pyx_GIVEREF(__pyx_v__rms); + PyList_SET_ITEM(__pyx_t_8, 1, __pyx_v__rms); + __Pyx_INCREF(__pyx_v_r2_d2); + __Pyx_GIVEREF(__pyx_v_r2_d2); + PyList_SET_ITEM(__pyx_t_8, 2, __pyx_v_r2_d2); + __pyx_r = __pyx_t_8; + __pyx_t_8 = 0; + goto __pyx_L0; + + /* "analysis.py":613 + * + * + * def poly_regression(x, y, power): # <<<<<<<<<<<<<< + * + * if x == "null": # if x is 'null', then x will be filled with integer points between 1 and the size of y + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_AddTraceback("analysis.poly_regression", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_reg_eq); + __Pyx_XDECREF(__pyx_v_eq_str); + __Pyx_XDECREF(__pyx_v_vals); + __Pyx_XDECREF(__pyx_v_z); + __Pyx_XDECREF(__pyx_v__rms); + __Pyx_XDECREF(__pyx_v_r2_d2); + __Pyx_XDECREF(__pyx_v_x); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":649 + * + * + * def log_regression(x, y, base): # <<<<<<<<<<<<<< + * + * x_fit = [] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_17log_regression(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_17log_regression = {"log_regression", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_17log_regression, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_17log_regression(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_x = 0; + PyObject *__pyx_v_y = 0; + PyObject *__pyx_v_base = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("log_regression (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_base,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_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("log_regression", 1, 3, 3, 1); __PYX_ERR(0, 649, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_base)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("log_regression", 1, 3, 3, 2); __PYX_ERR(0, 649, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "log_regression") < 0)) __PYX_ERR(0, 649, __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_x = values[0]; + __pyx_v_y = values[1]; + __pyx_v_base = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("log_regression", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 649, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.log_regression", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_16log_regression(__pyx_self, __pyx_v_x, __pyx_v_y, __pyx_v_base); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_16log_regression(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y, PyObject *__pyx_v_base) { + PyObject *__pyx_v_x_fit = NULL; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_v_reg_eq = NULL; + PyObject *__pyx_v_q_str = NULL; + PyObject *__pyx_v_vals = NULL; + PyObject *__pyx_v_z = NULL; + PyObject *__pyx_v__rms = NULL; + PyObject *__pyx_v_r2_d2 = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __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_t_12; + __Pyx_RefNannySetupContext("log_regression", 0); + + /* "analysis.py":651 + * def log_regression(x, y, base): + * + * x_fit = [] # <<<<<<<<<<<<<< + * + * for i in range(len(x)): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_x_fit = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":653 + * x_fit = [] + * + * for i in range(len(x)): # <<<<<<<<<<<<<< + * try: + * # change of base for logs + */ + __pyx_t_2 = PyObject_Length(__pyx_v_x); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 653, __pyx_L1_error) + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "analysis.py":654 + * + * for i in range(len(x)): + * try: # <<<<<<<<<<<<<< + * # change of base for logs + * x_fit.append(np.log(x[i]) / np.log(base)) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + /*try:*/ { + + /* "analysis.py":656 + * try: + * # change of base for logs + * x_fit.append(np.log(x[i]) / np.log(base)) # <<<<<<<<<<<<<< + * except: + * pass + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 656, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_log); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 656, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_x, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 656, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + __pyx_t_1 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_10, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 656, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 656, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_log); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 656, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + } + } + __pyx_t_9 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_8, __pyx_v_base) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_base); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 656, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 656, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_x_fit, __pyx_t_10); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 656, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "analysis.py":654 + * + * for i in range(len(x)): + * try: # <<<<<<<<<<<<<< + * # change of base for logs + * x_fit.append(np.log(x[i]) / np.log(base)) + */ + } + __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; + goto __pyx_L12_try_end; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":657 + * # change of base for logs + * x_fit.append(np.log(x[i]) / np.log(base)) + * except: # <<<<<<<<<<<<<< + * pass + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L6_exception_handled; + } + __pyx_L6_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); + __pyx_L12_try_end:; + } + } + + /* "analysis.py":661 + * + * # y = reg_eq[0] * log(x, base) + reg_eq[1] + * reg_eq = np.polyfit(x_fit, y, 1) # <<<<<<<<<<<<<< + * q_str = str(reg_eq[0]) + "* (np.log(z) / np.log(" + \ + * str(base) + "))+" + str(reg_eq[1]) + */ + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 661, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_polyfit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 661, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + __pyx_t_12 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_12 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_v_x_fit, __pyx_v_y, __pyx_int_1}; + __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 661, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_10); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_v_x_fit, __pyx_v_y, __pyx_int_1}; + __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 661, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_10); + } else + #endif + { + __pyx_t_8 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 661, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_9) { + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_9); __pyx_t_9 = NULL; + } + __Pyx_INCREF(__pyx_v_x_fit); + __Pyx_GIVEREF(__pyx_v_x_fit); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_12, __pyx_v_x_fit); + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_12, __pyx_v_y); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_12, __pyx_int_1); + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_8, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 661, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_reg_eq = __pyx_t_10; + __pyx_t_10 = 0; + + /* "analysis.py":662 + * # y = reg_eq[0] * log(x, base) + reg_eq[1] + * reg_eq = np.polyfit(x_fit, y, 1) + * q_str = str(reg_eq[0]) + "* (np.log(z) / np.log(" + \ # <<<<<<<<<<<<<< + * str(base) + "))+" + str(reg_eq[1]) + * vals = [] + */ + __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_reg_eq, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = PyNumber_Add(__pyx_t_1, __pyx_kp_s_np_log_z_np_log); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":663 + * reg_eq = np.polyfit(x_fit, y, 1) + * q_str = str(reg_eq[0]) + "* (np.log(z) / np.log(" + \ + * str(base) + "))+" + str(reg_eq[1]) # <<<<<<<<<<<<<< + * vals = [] + * + */ + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_v_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "analysis.py":662 + * # y = reg_eq[0] * log(x, base) + reg_eq[1] + * reg_eq = np.polyfit(x_fit, y, 1) + * q_str = str(reg_eq[0]) + "* (np.log(z) / np.log(" + \ # <<<<<<<<<<<<<< + * str(base) + "))+" + str(reg_eq[1]) + * vals = [] + */ + __pyx_t_8 = PyNumber_Add(__pyx_t_10, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":663 + * reg_eq = np.polyfit(x_fit, y, 1) + * q_str = str(reg_eq[0]) + "* (np.log(z) / np.log(" + \ + * str(base) + "))+" + str(reg_eq[1]) # <<<<<<<<<<<<<< + * vals = [] + * + */ + __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_kp_s__7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_reg_eq, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(__pyx_t_1, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_v_q_str = __pyx_t_8; + __pyx_t_8 = 0; + + /* "analysis.py":664 + * q_str = str(reg_eq[0]) + "* (np.log(z) / np.log(" + \ + * str(base) + "))+" + str(reg_eq[1]) + * vals = [] # <<<<<<<<<<<<<< + * + * for i in range(len(x)): + */ + __pyx_t_8 = PyList_New(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 664, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_v_vals = ((PyObject*)__pyx_t_8); + __pyx_t_8 = 0; + + /* "analysis.py":666 + * vals = [] + * + * for i in range(len(x)): # <<<<<<<<<<<<<< + * z = x[i] + * + */ + __pyx_t_2 = PyObject_Length(__pyx_v_x); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 666, __pyx_L1_error) + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "analysis.py":667 + * + * for i in range(len(x)): + * z = x[i] # <<<<<<<<<<<<<< + * + * try: + */ + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_x, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 667, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_z, __pyx_t_8); + __pyx_t_8 = 0; + + /* "analysis.py":669 + * z = x[i] + * + * try: # <<<<<<<<<<<<<< + * exec("vals.append(" + eq_str + ")") + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_5); + /*try:*/ { + + /* "analysis.py":670 + * + * try: + * exec("vals.append(" + eq_str + ")") # <<<<<<<<<<<<<< + * except: + * pass + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_eq_str); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 670, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = PyNumber_Add(__pyx_kp_s_vals_append, __pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 670, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(__pyx_t_10, __pyx_kp_s__6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 670, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_Globals(); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 670, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_1 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 670, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_1); + if (__pyx_v__rms) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_rms, __pyx_v__rms) < 0) __PYX_ERR(0, 670, __pyx_L15_error) + } + if (__pyx_v_base) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_base, __pyx_v_base) < 0) __PYX_ERR(0, 670, __pyx_L15_error) + } + __pyx_t_9 = PyInt_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 670, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_9) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i, __pyx_t_9) < 0) __PYX_ERR(0, 670, __pyx_L15_error) + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (__pyx_v_q_str) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_q_str, __pyx_v_q_str) < 0) __PYX_ERR(0, 670, __pyx_L15_error) + } + if (__pyx_v_r2_d2) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_r2_d2, __pyx_v_r2_d2) < 0) __PYX_ERR(0, 670, __pyx_L15_error) + } + if (__pyx_v_reg_eq) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_reg_eq, __pyx_v_reg_eq) < 0) __PYX_ERR(0, 670, __pyx_L15_error) + } + if (__pyx_v_vals) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_vals, __pyx_v_vals) < 0) __PYX_ERR(0, 670, __pyx_L15_error) + } + if (__pyx_v_x) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_x, __pyx_v_x) < 0) __PYX_ERR(0, 670, __pyx_L15_error) + } + if (__pyx_v_x_fit) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_x_fit, __pyx_v_x_fit) < 0) __PYX_ERR(0, 670, __pyx_L15_error) + } + if (__pyx_v_y) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 670, __pyx_L15_error) + } + if (__pyx_v_z) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_z_2, __pyx_v_z) < 0) __PYX_ERR(0, 670, __pyx_L15_error) + } + __pyx_t_9 = __Pyx_PyExec3(__pyx_t_8, __pyx_t_10, __pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 670, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":669 + * z = x[i] + * + * try: # <<<<<<<<<<<<<< + * exec("vals.append(" + eq_str + ")") + * except: + */ + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L22_try_end; + __pyx_L15_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":671 + * try: + * exec("vals.append(" + eq_str + ")") + * except: # <<<<<<<<<<<<<< + * pass + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L16_exception_handled; + } + __pyx_L16_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_6, __pyx_t_5); + __pyx_L22_try_end:; + } + } + + /* "analysis.py":674 + * pass + * + * _rms = rms(vals, y) # <<<<<<<<<<<<<< + * r2_d2 = r_squared(vals, y) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_rms_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_10 = NULL; + __pyx_t_12 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_12 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_vals, __pyx_v_y}; + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 674, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_vals, __pyx_v_y}; + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 674, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_10) { + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_10); __pyx_t_10 = NULL; + } + __Pyx_INCREF(__pyx_v_vals); + __Pyx_GIVEREF(__pyx_v_vals); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_12, __pyx_v_vals); + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_12, __pyx_v_y); + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_8, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v__rms = __pyx_t_9; + __pyx_t_9 = 0; + + /* "analysis.py":675 + * + * _rms = rms(vals, y) + * r2_d2 = r_squared(vals, y) # <<<<<<<<<<<<<< + * + * return eq_str, _rms, r2_d2 + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_r_squared); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 675, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = NULL; + __pyx_t_12 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_12 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_vals, __pyx_v_y}; + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 675, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_vals, __pyx_v_y}; + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 675, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else + #endif + { + __pyx_t_10 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 675, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_INCREF(__pyx_v_vals); + __Pyx_GIVEREF(__pyx_v_vals); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_12, __pyx_v_vals); + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_12, __pyx_v_y); + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 675, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_r2_d2 = __pyx_t_9; + __pyx_t_9 = 0; + + /* "analysis.py":677 + * r2_d2 = r_squared(vals, y) + * + * return eq_str, _rms, r2_d2 # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_eq_str); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_9); + __Pyx_INCREF(__pyx_v__rms); + __Pyx_GIVEREF(__pyx_v__rms); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v__rms); + __Pyx_INCREF(__pyx_v_r2_d2); + __Pyx_GIVEREF(__pyx_v_r2_d2); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_r2_d2); + __pyx_t_9 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "analysis.py":649 + * + * + * def log_regression(x, y, base): # <<<<<<<<<<<<<< + * + * x_fit = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("analysis.log_regression", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_x_fit); + __Pyx_XDECREF(__pyx_v_reg_eq); + __Pyx_XDECREF(__pyx_v_q_str); + __Pyx_XDECREF(__pyx_v_vals); + __Pyx_XDECREF(__pyx_v_z); + __Pyx_XDECREF(__pyx_v__rms); + __Pyx_XDECREF(__pyx_v_r2_d2); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":680 + * + * + * def exp_regression(x, y, base): # <<<<<<<<<<<<<< + * + * y_fit = [] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_19exp_regression(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_19exp_regression = {"exp_regression", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_19exp_regression, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_19exp_regression(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_x = 0; + PyObject *__pyx_v_y = 0; + PyObject *__pyx_v_base = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("exp_regression (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_base,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_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("exp_regression", 1, 3, 3, 1); __PYX_ERR(0, 680, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_base)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("exp_regression", 1, 3, 3, 2); __PYX_ERR(0, 680, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "exp_regression") < 0)) __PYX_ERR(0, 680, __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_x = values[0]; + __pyx_v_y = values[1]; + __pyx_v_base = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("exp_regression", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 680, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.exp_regression", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_18exp_regression(__pyx_self, __pyx_v_x, __pyx_v_y, __pyx_v_base); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_18exp_regression(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y, PyObject *__pyx_v_base) { + PyObject *__pyx_v_y_fit = NULL; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_v_reg_eq = NULL; + PyObject *__pyx_v_eq_str = NULL; + PyObject *__pyx_v_vals = NULL; + PyObject *__pyx_v_z = NULL; + PyObject *__pyx_v__rms = NULL; + PyObject *__pyx_v_r2_d2 = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __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; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + int __pyx_t_14; + __Pyx_RefNannySetupContext("exp_regression", 0); + + /* "analysis.py":682 + * def exp_regression(x, y, base): + * + * y_fit = [] # <<<<<<<<<<<<<< + * + * for i in range(len(y)): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_y_fit = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":684 + * y_fit = [] + * + * for i in range(len(y)): # <<<<<<<<<<<<<< + * try: + * # change of base for logs + */ + __pyx_t_2 = PyObject_Length(__pyx_v_y); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 684, __pyx_L1_error) + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "analysis.py":685 + * + * for i in range(len(y)): + * try: # <<<<<<<<<<<<<< + * # change of base for logs + * y_fit.append(np.log(y[i]) / np.log(base)) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + /*try:*/ { + + /* "analysis.py":687 + * try: + * # change of base for logs + * y_fit.append(np.log(y[i]) / np.log(base)) # <<<<<<<<<<<<<< + * except: + * pass + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 687, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_log); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 687, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_y, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 687, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + __pyx_t_1 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_10, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 687, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 687, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_log); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 687, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + } + } + __pyx_t_9 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_8, __pyx_v_base) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_base); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 687, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 687, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_y_fit, __pyx_t_10); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 687, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "analysis.py":685 + * + * for i in range(len(y)): + * try: # <<<<<<<<<<<<<< + * # change of base for logs + * y_fit.append(np.log(y[i]) / np.log(base)) + */ + } + __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; + goto __pyx_L12_try_end; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":688 + * # change of base for logs + * y_fit.append(np.log(y[i]) / np.log(base)) + * except: # <<<<<<<<<<<<<< + * pass + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L6_exception_handled; + } + __pyx_L6_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); + __pyx_L12_try_end:; + } + } + + /* "analysis.py":692 + * + * # y = base ^ (reg_eq[0] * x) * base ^ (reg_eq[1]) + * reg_eq = np.polyfit(x, y_fit, 1, w=np.sqrt(y_fit)) # <<<<<<<<<<<<<< + * eq_str = "(" + str(base) + "**(" + \ + * str(reg_eq[0]) + "*z))*(" + str(base) + "**(" + str(reg_eq[1]) + "))" + */ + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 692, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_polyfit); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 692, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = PyTuple_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 692, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_v_x); + __Pyx_GIVEREF(__pyx_v_x); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_v_x); + __Pyx_INCREF(__pyx_v_y_fit); + __Pyx_GIVEREF(__pyx_v_y_fit); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_v_y_fit); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_int_1); + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 692, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_np); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 692, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 692, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + } + } + __pyx_t_8 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_12, __pyx_v_y_fit) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_v_y_fit); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 692, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_w, __pyx_t_8) < 0) __PYX_ERR(0, 692, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 692, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_reg_eq = __pyx_t_8; + __pyx_t_8 = 0; + + /* "analysis.py":693 + * # y = base ^ (reg_eq[0] * x) * base ^ (reg_eq[1]) + * reg_eq = np.polyfit(x, y_fit, 1, w=np.sqrt(y_fit)) + * eq_str = "(" + str(base) + "**(" + \ # <<<<<<<<<<<<<< + * str(reg_eq[0]) + "*z))*(" + str(base) + "**(" + str(reg_eq[1]) + "))" + * vals = [] + */ + __pyx_t_8 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_v_base); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = PyNumber_Add(__pyx_kp_s__8, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(__pyx_t_1, __pyx_kp_s__9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":694 + * reg_eq = np.polyfit(x, y_fit, 1, w=np.sqrt(y_fit)) + * eq_str = "(" + str(base) + "**(" + \ + * str(reg_eq[0]) + "*z))*(" + str(base) + "**(" + str(reg_eq[1]) + "))" # <<<<<<<<<<<<<< + * vals = [] + * + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_reg_eq, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_10 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":693 + * # y = base ^ (reg_eq[0] * x) * base ^ (reg_eq[1]) + * reg_eq = np.polyfit(x, y_fit, 1, w=np.sqrt(y_fit)) + * eq_str = "(" + str(base) + "**(" + \ # <<<<<<<<<<<<<< + * str(reg_eq[0]) + "*z))*(" + str(base) + "**(" + str(reg_eq[1]) + "))" + * vals = [] + */ + __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "analysis.py":694 + * reg_eq = np.polyfit(x, y_fit, 1, w=np.sqrt(y_fit)) + * eq_str = "(" + str(base) + "**(" + \ + * str(reg_eq[0]) + "*z))*(" + str(base) + "**(" + str(reg_eq[1]) + "))" # <<<<<<<<<<<<<< + * vals = [] + * + */ + __pyx_t_10 = PyNumber_Add(__pyx_t_1, __pyx_kp_s_z_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_v_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = PyNumber_Add(__pyx_t_10, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_kp_s__9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_reg_eq, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(__pyx_t_1, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = PyNumber_Add(__pyx_t_8, __pyx_kp_s__10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_eq_str = __pyx_t_10; + __pyx_t_10 = 0; + + /* "analysis.py":695 + * eq_str = "(" + str(base) + "**(" + \ + * str(reg_eq[0]) + "*z))*(" + str(base) + "**(" + str(reg_eq[1]) + "))" + * vals = [] # <<<<<<<<<<<<<< + * + * for i in range(len(x)): + */ + __pyx_t_10 = PyList_New(0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 695, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_v_vals = ((PyObject*)__pyx_t_10); + __pyx_t_10 = 0; + + /* "analysis.py":697 + * vals = [] + * + * for i in range(len(x)): # <<<<<<<<<<<<<< + * z = x[i] + * + */ + __pyx_t_2 = PyObject_Length(__pyx_v_x); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 697, __pyx_L1_error) + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "analysis.py":698 + * + * for i in range(len(x)): + * z = x[i] # <<<<<<<<<<<<<< + * + * try: + */ + __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_x, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_XDECREF_SET(__pyx_v_z, __pyx_t_10); + __pyx_t_10 = 0; + + /* "analysis.py":700 + * z = x[i] + * + * try: # <<<<<<<<<<<<<< + * exec("vals.append(" + eq_str + ")") + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_5); + /*try:*/ { + + /* "analysis.py":701 + * + * try: + * exec("vals.append(" + eq_str + ")") # <<<<<<<<<<<<<< + * except: + * pass + */ + __pyx_t_10 = PyNumber_Add(__pyx_kp_s_vals_append, __pyx_v_eq_str); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 701, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_8 = PyNumber_Add(__pyx_t_10, __pyx_kp_s__6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 701, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_Globals(); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 701, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_1 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 701, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_1); + if (__pyx_v__rms) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_rms, __pyx_v__rms) < 0) __PYX_ERR(0, 701, __pyx_L15_error) + } + if (__pyx_v_base) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_base, __pyx_v_base) < 0) __PYX_ERR(0, 701, __pyx_L15_error) + } + if (__pyx_v_eq_str) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_eq_str, __pyx_v_eq_str) < 0) __PYX_ERR(0, 701, __pyx_L15_error) + } + __pyx_t_9 = PyInt_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 701, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_9) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i, __pyx_t_9) < 0) __PYX_ERR(0, 701, __pyx_L15_error) + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (__pyx_v_r2_d2) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_r2_d2, __pyx_v_r2_d2) < 0) __PYX_ERR(0, 701, __pyx_L15_error) + } + if (__pyx_v_reg_eq) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_reg_eq, __pyx_v_reg_eq) < 0) __PYX_ERR(0, 701, __pyx_L15_error) + } + if (__pyx_v_vals) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_vals, __pyx_v_vals) < 0) __PYX_ERR(0, 701, __pyx_L15_error) + } + if (__pyx_v_x) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_x, __pyx_v_x) < 0) __PYX_ERR(0, 701, __pyx_L15_error) + } + if (__pyx_v_y) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 701, __pyx_L15_error) + } + if (__pyx_v_y_fit) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_y_fit, __pyx_v_y_fit) < 0) __PYX_ERR(0, 701, __pyx_L15_error) + } + if (__pyx_v_z) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_z_2, __pyx_v_z) < 0) __PYX_ERR(0, 701, __pyx_L15_error) + } + __pyx_t_9 = __Pyx_PyExec3(__pyx_t_8, __pyx_t_10, __pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 701, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":700 + * z = x[i] + * + * try: # <<<<<<<<<<<<<< + * exec("vals.append(" + eq_str + ")") + * except: + */ + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L22_try_end; + __pyx_L15_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":702 + * try: + * exec("vals.append(" + eq_str + ")") + * except: # <<<<<<<<<<<<<< + * pass + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L16_exception_handled; + } + __pyx_L16_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_6, __pyx_t_5); + __pyx_L22_try_end:; + } + } + + /* "analysis.py":705 + * pass + * + * _rms = rms(vals, y) # <<<<<<<<<<<<<< + * r2_d2 = r_squared(vals, y) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_rms_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_10 = NULL; + __pyx_t_14 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_14 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_vals, __pyx_v_y}; + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 705, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_vals, __pyx_v_y}; + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 705, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_10) { + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_10); __pyx_t_10 = NULL; + } + __Pyx_INCREF(__pyx_v_vals); + __Pyx_GIVEREF(__pyx_v_vals); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_14, __pyx_v_vals); + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_14, __pyx_v_y); + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_8, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v__rms = __pyx_t_9; + __pyx_t_9 = 0; + + /* "analysis.py":706 + * + * _rms = rms(vals, y) + * r2_d2 = r_squared(vals, y) # <<<<<<<<<<<<<< + * + * return eq_str, _rms, r2_d2 + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_r_squared); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = NULL; + __pyx_t_14 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_14 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_vals, __pyx_v_y}; + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 706, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_vals, __pyx_v_y}; + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 706, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_9); + } else + #endif + { + __pyx_t_10 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_INCREF(__pyx_v_vals); + __Pyx_GIVEREF(__pyx_v_vals); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_14, __pyx_v_vals); + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_14, __pyx_v_y); + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_r2_d2 = __pyx_t_9; + __pyx_t_9 = 0; + + /* "analysis.py":708 + * r2_d2 = r_squared(vals, y) + * + * return eq_str, _rms, r2_d2 # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_9 = PyTuple_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_INCREF(__pyx_v_eq_str); + __Pyx_GIVEREF(__pyx_v_eq_str); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_v_eq_str); + __Pyx_INCREF(__pyx_v__rms); + __Pyx_GIVEREF(__pyx_v__rms); + PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_v__rms); + __Pyx_INCREF(__pyx_v_r2_d2); + __Pyx_GIVEREF(__pyx_v_r2_d2); + PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_v_r2_d2); + __pyx_r = __pyx_t_9; + __pyx_t_9 = 0; + goto __pyx_L0; + + /* "analysis.py":680 + * + * + * def exp_regression(x, y, base): # <<<<<<<<<<<<<< + * + * y_fit = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_AddTraceback("analysis.exp_regression", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_y_fit); + __Pyx_XDECREF(__pyx_v_reg_eq); + __Pyx_XDECREF(__pyx_v_eq_str); + __Pyx_XDECREF(__pyx_v_vals); + __Pyx_XDECREF(__pyx_v_z); + __Pyx_XDECREF(__pyx_v__rms); + __Pyx_XDECREF(__pyx_v_r2_d2); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":711 + * + * + * def tanh_regression(x, y): # <<<<<<<<<<<<<< + * + * def tanh(x, a, b, c, d): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_21tanh_regression(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_21tanh_regression = {"tanh_regression", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_21tanh_regression, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_21tanh_regression(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_x = 0; + PyObject *__pyx_v_y = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("tanh_regression (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("tanh_regression", 1, 2, 2, 1); __PYX_ERR(0, 711, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "tanh_regression") < 0)) __PYX_ERR(0, 711, __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 = values[0]; + __pyx_v_y = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("tanh_regression", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 711, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.tanh_regression", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_20tanh_regression(__pyx_self, __pyx_v_x, __pyx_v_y); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":713 + * def tanh_regression(x, y): + * + * def tanh(x, a, b, c, d): # <<<<<<<<<<<<<< + * + * return a * np.tanh(b * (x - c)) + d + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_15tanh_regression_1tanh(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_15tanh_regression_1tanh = {"tanh", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_15tanh_regression_1tanh, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_15tanh_regression_1tanh(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_x = 0; + PyObject *__pyx_v_a = 0; + PyObject *__pyx_v_b = 0; + PyObject *__pyx_v_c = 0; + PyObject *__pyx_v_d = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("tanh (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_a,&__pyx_n_s_b,&__pyx_n_s_c,&__pyx_n_s_d,0}; + PyObject* values[5] = {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 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_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_a)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("tanh", 1, 5, 5, 1); __PYX_ERR(0, 713, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_b)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("tanh", 1, 5, 5, 2); __PYX_ERR(0, 713, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("tanh", 1, 5, 5, 3); __PYX_ERR(0, 713, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_d)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("tanh", 1, 5, 5, 4); __PYX_ERR(0, 713, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "tanh") < 0)) __PYX_ERR(0, 713, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { + 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); + } + __pyx_v_x = values[0]; + __pyx_v_a = values[1]; + __pyx_v_b = values[2]; + __pyx_v_c = values[3]; + __pyx_v_d = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("tanh", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 713, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.tanh_regression.tanh", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_15tanh_regression_tanh(__pyx_self, __pyx_v_x, __pyx_v_a, __pyx_v_b, __pyx_v_c, __pyx_v_d); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_15tanh_regression_tanh(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + 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; + __Pyx_RefNannySetupContext("tanh", 0); + + /* "analysis.py":715 + * def tanh(x, a, b, c, d): + * + * return a * np.tanh(b * (x - c)) + d # <<<<<<<<<<<<<< + * + * reg_eq = np.float64(curve_fit(tanh, np.array(x), np.array(y))[0]).tolist() + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_tanh); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Subtract(__pyx_v_x, __pyx_v_c); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyNumber_Multiply(__pyx_v_b, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Multiply(__pyx_v_a, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_v_d); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "analysis.py":713 + * def tanh_regression(x, y): + * + * def tanh(x, a, b, c, d): # <<<<<<<<<<<<<< + * + * return a * np.tanh(b * (x - c)) + d + */ + + /* 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("analysis.tanh_regression.tanh", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":711 + * + * + * def tanh_regression(x, y): # <<<<<<<<<<<<<< + * + * def tanh(x, a, b, c, d): + */ + +static PyObject *__pyx_pf_8analysis_20tanh_regression(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y) { + PyObject *__pyx_v_tanh = 0; + PyObject *__pyx_v_reg_eq = NULL; + PyObject *__pyx_v_eq_str = NULL; + PyObject *__pyx_v_vals = NULL; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_v_z = NULL; + PyObject *__pyx_v__rms = NULL; + PyObject *__pyx_v_r2_d2 = 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 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + Py_ssize_t __pyx_t_11; + Py_ssize_t __pyx_t_12; + Py_ssize_t __pyx_t_13; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + __Pyx_RefNannySetupContext("tanh_regression", 0); + + /* "analysis.py":713 + * def tanh_regression(x, y): + * + * def tanh(x, a, b, c, d): # <<<<<<<<<<<<<< + * + * return a * np.tanh(b * (x - c)) + d + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_15tanh_regression_1tanh, 0, __pyx_n_s_tanh_regression_locals_tanh, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 713, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_tanh = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":717 + * return a * np.tanh(b * (x - c)) + d + * + * reg_eq = np.float64(curve_fit(tanh, np.array(x), np.array(y))[0]).tolist() # <<<<<<<<<<<<<< + * eq_str = str(reg_eq[0]) + " * np.tanh(" + str(reg_eq[1]) + \ + * "*(z - " + str(reg_eq[2]) + ")) + " + str(reg_eq[3]) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_float64); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_curve_fit); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + __pyx_t_6 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_v_x) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_x); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + __pyx_t_8 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_7, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_y); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_v_tanh, __pyx_t_6, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_v_tanh, __pyx_t_6, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(3+__pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_9) { + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9); __pyx_t_9 = NULL; + } + __Pyx_INCREF(__pyx_v_tanh); + __Pyx_GIVEREF(__pyx_v_tanh); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_10, __pyx_v_tanh); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_10, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_10, __pyx_t_8); + __pyx_t_6 = 0; + __pyx_t_8 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(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_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_tolist); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __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_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_reg_eq = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":718 + * + * reg_eq = np.float64(curve_fit(tanh, np.array(x), np.array(y))[0]).tolist() + * eq_str = str(reg_eq[0]) + " * np.tanh(" + str(reg_eq[1]) + \ # <<<<<<<<<<<<<< + * "*(z - " + str(reg_eq[2]) + ")) + " + str(reg_eq[3]) + * vals = [] + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_reg_eq, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 718, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 718, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_4, __pyx_kp_s_np_tanh); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 718, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_reg_eq, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 718, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 718, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 718, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Add(__pyx_t_4, __pyx_kp_s_z_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 718, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "analysis.py":719 + * reg_eq = np.float64(curve_fit(tanh, np.array(x), np.array(y))[0]).tolist() + * eq_str = str(reg_eq[0]) + " * np.tanh(" + str(reg_eq[1]) + \ + * "*(z - " + str(reg_eq[2]) + ")) + " + str(reg_eq[3]) # <<<<<<<<<<<<<< + * vals = [] + * + */ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_reg_eq, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 719, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 719, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Add(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 719, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_4, __pyx_kp_s__13); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 719, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_reg_eq, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 719, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 719, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 719, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_eq_str = __pyx_t_4; + __pyx_t_4 = 0; + + /* "analysis.py":720 + * eq_str = str(reg_eq[0]) + " * np.tanh(" + str(reg_eq[1]) + \ + * "*(z - " + str(reg_eq[2]) + ")) + " + str(reg_eq[3]) + * vals = [] # <<<<<<<<<<<<<< + * + * for i in range(len(x)): + */ + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 720, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_vals = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "analysis.py":722 + * vals = [] + * + * for i in range(len(x)): # <<<<<<<<<<<<<< + * z = x[i] + * try: + */ + __pyx_t_11 = PyObject_Length(__pyx_v_x); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(0, 722, __pyx_L1_error) + __pyx_t_12 = __pyx_t_11; + for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { + __pyx_v_i = __pyx_t_13; + + /* "analysis.py":723 + * + * for i in range(len(x)): + * z = x[i] # <<<<<<<<<<<<<< + * try: + * exec("vals.append(" + eq_str + ")") + */ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_x, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 723, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_z, __pyx_t_4); + __pyx_t_4 = 0; + + /* "analysis.py":724 + * for i in range(len(x)): + * z = x[i] + * try: # <<<<<<<<<<<<<< + * exec("vals.append(" + eq_str + ")") + * except: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_16); + /*try:*/ { + + /* "analysis.py":725 + * z = x[i] + * try: + * exec("vals.append(" + eq_str + ")") # <<<<<<<<<<<<<< + * except: + * pass + */ + __pyx_t_4 = PyNumber_Add(__pyx_kp_s_vals_append, __pyx_v_eq_str); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 725, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = PyNumber_Add(__pyx_t_4, __pyx_kp_s__6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 725, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_Globals(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 725, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyDict_NewPresized(10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 725, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); + if (__pyx_v__rms) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_rms, __pyx_v__rms) < 0) __PYX_ERR(0, 725, __pyx_L5_error) + } + if (__pyx_v_eq_str) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_eq_str, __pyx_v_eq_str) < 0) __PYX_ERR(0, 725, __pyx_L5_error) + } + __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 725, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_5) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i, __pyx_t_5) < 0) __PYX_ERR(0, 725, __pyx_L5_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__pyx_v_r2_d2) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_r2_d2, __pyx_v_r2_d2) < 0) __PYX_ERR(0, 725, __pyx_L5_error) + } + if (__pyx_v_reg_eq) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_reg_eq, __pyx_v_reg_eq) < 0) __PYX_ERR(0, 725, __pyx_L5_error) + } + if (__pyx_v_tanh) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_tanh, __pyx_v_tanh) < 0) __PYX_ERR(0, 725, __pyx_L5_error) + } + if (__pyx_v_vals) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_vals, __pyx_v_vals) < 0) __PYX_ERR(0, 725, __pyx_L5_error) + } + if (__pyx_v_x) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_x, __pyx_v_x) < 0) __PYX_ERR(0, 725, __pyx_L5_error) + } + if (__pyx_v_y) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 725, __pyx_L5_error) + } + if (__pyx_v_z) { + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_z_2, __pyx_v_z) < 0) __PYX_ERR(0, 725, __pyx_L5_error) + } + __pyx_t_5 = __Pyx_PyExec3(__pyx_t_2, __pyx_t_4, __pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 725, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "analysis.py":724 + * for i in range(len(x)): + * z = x[i] + * try: # <<<<<<<<<<<<<< + * exec("vals.append(" + eq_str + ")") + * except: + */ + } + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + goto __pyx_L12_try_end; + __pyx_L5_error:; + __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; + __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; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":726 + * try: + * exec("vals.append(" + eq_str + ")") + * except: # <<<<<<<<<<<<<< + * pass + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L6_exception_handled; + } + __pyx_L6_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); + __pyx_L12_try_end:; + } + } + + /* "analysis.py":729 + * pass + * + * _rms = rms(vals, y) # <<<<<<<<<<<<<< + * r2_d2 = r_squared(vals, y) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_rms_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 729, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_vals, __pyx_v_y}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 729, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_vals, __pyx_v_y}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 729, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + { + __pyx_t_2 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 729, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(__pyx_v_vals); + __Pyx_GIVEREF(__pyx_v_vals); + PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_10, __pyx_v_vals); + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_10, __pyx_v_y); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 729, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v__rms = __pyx_t_5; + __pyx_t_5 = 0; + + /* "analysis.py":730 + * + * _rms = rms(vals, y) + * r2_d2 = r_squared(vals, y) # <<<<<<<<<<<<<< + * + * return eq_str, _rms, r2_d2 + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_r_squared); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 730, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_vals, __pyx_v_y}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 730, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_vals, __pyx_v_y}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 730, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + { + __pyx_t_4 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 730, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_INCREF(__pyx_v_vals); + __Pyx_GIVEREF(__pyx_v_vals); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_10, __pyx_v_vals); + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_10, __pyx_v_y); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 730, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_r2_d2 = __pyx_t_5; + __pyx_t_5 = 0; + + /* "analysis.py":732 + * r2_d2 = r_squared(vals, y) + * + * return eq_str, _rms, r2_d2 # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 732, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_eq_str); + __Pyx_GIVEREF(__pyx_v_eq_str); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_eq_str); + __Pyx_INCREF(__pyx_v__rms); + __Pyx_GIVEREF(__pyx_v__rms); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v__rms); + __Pyx_INCREF(__pyx_v_r2_d2); + __Pyx_GIVEREF(__pyx_v_r2_d2); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_r2_d2); + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "analysis.py":711 + * + * + * def tanh_regression(x, y): # <<<<<<<<<<<<<< + * + * def tanh(x, a, b, c, d): + */ + + /* 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_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("analysis.tanh_regression", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_tanh); + __Pyx_XDECREF(__pyx_v_reg_eq); + __Pyx_XDECREF(__pyx_v_eq_str); + __Pyx_XDECREF(__pyx_v_vals); + __Pyx_XDECREF(__pyx_v_z); + __Pyx_XDECREF(__pyx_v__rms); + __Pyx_XDECREF(__pyx_v_r2_d2); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":735 + * + * + * def r_squared(predictions, targets): # assumes equal size inputs # <<<<<<<<<<<<<< + * + * return metrics.r2_score(np.array(targets), np.array(predictions)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_23r_squared(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_23r_squared = {"r_squared", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_23r_squared, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_23r_squared(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_predictions = 0; + PyObject *__pyx_v_targets = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("r_squared (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_predictions,&__pyx_n_s_targets,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_predictions)) != 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_targets)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("r_squared", 1, 2, 2, 1); __PYX_ERR(0, 735, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "r_squared") < 0)) __PYX_ERR(0, 735, __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_predictions = values[0]; + __pyx_v_targets = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("r_squared", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 735, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.r_squared", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_22r_squared(__pyx_self, __pyx_v_predictions, __pyx_v_targets); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_22r_squared(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_predictions, PyObject *__pyx_v_targets) { + 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; + int __pyx_t_7; + __Pyx_RefNannySetupContext("r_squared", 0); + + /* "analysis.py":737 + * def r_squared(predictions, targets): # assumes equal size inputs + * + * return metrics.r2_score(np.array(targets), np.array(predictions)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_metrics); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_r2_score); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_array); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, __pyx_v_targets) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_targets); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_array); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_4, __pyx_v_predictions) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_predictions); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_2, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 737, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_2, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 737, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_7, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_7, __pyx_t_5); + __pyx_t_2 = 0; + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 737, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "analysis.py":735 + * + * + * def r_squared(predictions, targets): # assumes equal size inputs # <<<<<<<<<<<<<< + * + * return metrics.r2_score(np.array(targets), np.array(predictions)) + */ + + /* 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("analysis.r_squared", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":740 + * + * + * def rms(predictions, targets): # assumes equal size inputs # <<<<<<<<<<<<<< + * + * _sum = 0 + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_25rms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_25rms = {"rms", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_25rms, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_25rms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_predictions = 0; + PyObject *__pyx_v_targets = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("rms (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_predictions,&__pyx_n_s_targets,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_predictions)) != 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_targets)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("rms", 1, 2, 2, 1); __PYX_ERR(0, 740, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "rms") < 0)) __PYX_ERR(0, 740, __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_predictions = values[0]; + __pyx_v_targets = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("rms", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 740, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.rms", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_24rms(__pyx_self, __pyx_v_predictions, __pyx_v_targets); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_24rms(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_predictions, PyObject *__pyx_v_targets) { + PyObject *__pyx_v__sum = NULL; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("rms", 0); + + /* "analysis.py":742 + * def rms(predictions, targets): # assumes equal size inputs + * + * _sum = 0 # <<<<<<<<<<<<<< + * + * for i in range(0, len(targets), 1): + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_v__sum = __pyx_int_0; + + /* "analysis.py":744 + * _sum = 0 + * + * for i in range(0, len(targets), 1): # <<<<<<<<<<<<<< + * _sum = (targets[i] - predictions[i]) ** 2 + * + */ + __pyx_t_1 = PyObject_Length(__pyx_v_targets); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 744, __pyx_L1_error) + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "analysis.py":745 + * + * for i in range(0, len(targets), 1): + * _sum = (targets[i] - predictions[i]) ** 2 # <<<<<<<<<<<<<< + * + * return float(math.sqrt(_sum / len(targets))) + */ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_targets, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 745, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_predictions, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 745, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyNumber_Subtract(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 745, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Power(__pyx_t_6, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 745, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF_SET(__pyx_v__sum, __pyx_t_5); + __pyx_t_5 = 0; + } + + /* "analysis.py":747 + * _sum = (targets[i] - predictions[i]) ** 2 + * + * return float(math.sqrt(_sum / len(targets))) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_math); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = PyObject_Length(__pyx_v_targets); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 747, __pyx_L1_error) + __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyNumber_Divide(__pyx_v__sum, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyNumber_Float(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "analysis.py":740 + * + * + * def rms(predictions, targets): # assumes equal size inputs # <<<<<<<<<<<<<< + * + * _sum = 0 + */ + + /* 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_AddTraceback("analysis.rms", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v__sum); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":750 + * + * + * def calc_overfit(equation, rms_train, r2_train, x_test, y_test): # <<<<<<<<<<<<<< + * + * # performance overfit = performance(train) - performance(test) where performance is r^2 + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_27calc_overfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_27calc_overfit = {"calc_overfit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_27calc_overfit, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_27calc_overfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_equation = 0; + PyObject *__pyx_v_rms_train = 0; + PyObject *__pyx_v_r2_train = 0; + PyObject *__pyx_v_x_test = 0; + PyObject *__pyx_v_y_test = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("calc_overfit (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_equation,&__pyx_n_s_rms_train,&__pyx_n_s_r2_train,&__pyx_n_s_x_test,&__pyx_n_s_y_test,0}; + PyObject* values[5] = {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 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_equation)) != 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_rms_train)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("calc_overfit", 1, 5, 5, 1); __PYX_ERR(0, 750, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_r2_train)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("calc_overfit", 1, 5, 5, 2); __PYX_ERR(0, 750, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x_test)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("calc_overfit", 1, 5, 5, 3); __PYX_ERR(0, 750, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y_test)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("calc_overfit", 1, 5, 5, 4); __PYX_ERR(0, 750, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "calc_overfit") < 0)) __PYX_ERR(0, 750, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { + 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); + } + __pyx_v_equation = values[0]; + __pyx_v_rms_train = values[1]; + __pyx_v_r2_train = values[2]; + __pyx_v_x_test = values[3]; + __pyx_v_y_test = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("calc_overfit", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 750, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.calc_overfit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_26calc_overfit(__pyx_self, __pyx_v_equation, __pyx_v_rms_train, __pyx_v_r2_train, __pyx_v_x_test, __pyx_v_y_test); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_26calc_overfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_equation, PyObject *__pyx_v_rms_train, PyObject *__pyx_v_r2_train, PyObject *__pyx_v_x_test, PyObject *__pyx_v_y_test) { + PyObject *__pyx_v_vals = NULL; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_v_z = NULL; + PyObject *__pyx_v_r2_test = NULL; + PyObject *__pyx_v_rms_test = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + __Pyx_RefNannySetupContext("calc_overfit", 0); + + /* "analysis.py":755 + * # error overfit = error(train) - error(test) where error is rms; biased towards smaller values + * + * vals = [] # <<<<<<<<<<<<<< + * + * for i in range(0, len(x_test), 1): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 755, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_vals = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":757 + * vals = [] + * + * for i in range(0, len(x_test), 1): # <<<<<<<<<<<<<< + * + * z = x_test[i] + */ + __pyx_t_2 = PyObject_Length(__pyx_v_x_test); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 757, __pyx_L1_error) + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "analysis.py":759 + * for i in range(0, len(x_test), 1): + * + * z = x_test[i] # <<<<<<<<<<<<<< + * + * exec("vals.append(" + equation + ")") + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_x_test, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_z, __pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":761 + * z = x_test[i] + * + * exec("vals.append(" + equation + ")") # <<<<<<<<<<<<<< + * + * r2_test = r_squared(vals, y_test) + */ + __pyx_t_1 = PyNumber_Add(__pyx_kp_s_vals_append, __pyx_v_equation); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 761, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PyNumber_Add(__pyx_t_1, __pyx_kp_s__6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 761, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_Globals(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 761, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyDict_NewPresized(10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 761, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_v_equation) { + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_equation, __pyx_v_equation) < 0) __PYX_ERR(0, 761, __pyx_L1_error) + } + __pyx_t_7 = PyInt_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 761, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_7) { + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_i, __pyx_t_7) < 0) __PYX_ERR(0, 761, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_v_r2_test) { + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_r2_test, __pyx_v_r2_test) < 0) __PYX_ERR(0, 761, __pyx_L1_error) + } + if (__pyx_v_r2_train) { + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_r2_train, __pyx_v_r2_train) < 0) __PYX_ERR(0, 761, __pyx_L1_error) + } + if (__pyx_v_rms_test) { + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_rms_test, __pyx_v_rms_test) < 0) __PYX_ERR(0, 761, __pyx_L1_error) + } + if (__pyx_v_rms_train) { + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_rms_train, __pyx_v_rms_train) < 0) __PYX_ERR(0, 761, __pyx_L1_error) + } + if (__pyx_v_vals) { + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_vals, __pyx_v_vals) < 0) __PYX_ERR(0, 761, __pyx_L1_error) + } + if (__pyx_v_x_test) { + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_x_test, __pyx_v_x_test) < 0) __PYX_ERR(0, 761, __pyx_L1_error) + } + if (__pyx_v_y_test) { + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_y_test, __pyx_v_y_test) < 0) __PYX_ERR(0, 761, __pyx_L1_error) + } + if (__pyx_v_z) { + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_z_2, __pyx_v_z) < 0) __PYX_ERR(0, 761, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyExec3(__pyx_t_5, __pyx_t_1, __pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 761, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + + /* "analysis.py":763 + * exec("vals.append(" + equation + ")") + * + * r2_test = r_squared(vals, y_test) # <<<<<<<<<<<<<< + * rms_test = rms(vals, y_test) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_r_squared); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_vals, __pyx_v_y_test}; + __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 763, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_7); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_vals, __pyx_v_y_test}; + __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 763, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_7); + } else + #endif + { + __pyx_t_5 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_1) { + __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); __pyx_t_1 = NULL; + } + __Pyx_INCREF(__pyx_v_vals); + __Pyx_GIVEREF(__pyx_v_vals); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_8, __pyx_v_vals); + __Pyx_INCREF(__pyx_v_y_test); + __Pyx_GIVEREF(__pyx_v_y_test); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_8, __pyx_v_y_test); + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_5, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_r2_test = __pyx_t_7; + __pyx_t_7 = 0; + + /* "analysis.py":764 + * + * r2_test = r_squared(vals, y_test) + * rms_test = rms(vals, y_test) # <<<<<<<<<<<<<< + * + * return r2_train - r2_test + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_rms_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_vals, __pyx_v_y_test}; + __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 764, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_7); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_vals, __pyx_v_y_test}; + __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 764, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_7); + } else + #endif + { + __pyx_t_1 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_INCREF(__pyx_v_vals); + __Pyx_GIVEREF(__pyx_v_vals); + PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_8, __pyx_v_vals); + __Pyx_INCREF(__pyx_v_y_test); + __Pyx_GIVEREF(__pyx_v_y_test); + PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_8, __pyx_v_y_test); + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_rms_test = __pyx_t_7; + __pyx_t_7 = 0; + + /* "analysis.py":766 + * rms_test = rms(vals, y_test) + * + * return r2_train - r2_test # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_7 = PyNumber_Subtract(__pyx_v_r2_train, __pyx_v_r2_test); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 766, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L0; + + /* "analysis.py":750 + * + * + * def calc_overfit(equation, rms_train, r2_train, x_test, y_test): # <<<<<<<<<<<<<< + * + * # performance overfit = performance(train) - performance(test) where performance is r^2 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("analysis.calc_overfit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_vals); + __Pyx_XDECREF(__pyx_v_z); + __Pyx_XDECREF(__pyx_v_r2_test); + __Pyx_XDECREF(__pyx_v_rms_test); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":769 + * + * + * def strip_data(data, mode): # <<<<<<<<<<<<<< + * + * if mode == "adam": # x is the row number, y are the data + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_29strip_data(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_29strip_data = {"strip_data", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_29strip_data, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_29strip_data(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED PyObject *__pyx_v_data = 0; + PyObject *__pyx_v_mode = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("strip_data (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_data,&__pyx_n_s_mode,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_data)) != 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_mode)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("strip_data", 1, 2, 2, 1); __PYX_ERR(0, 769, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "strip_data") < 0)) __PYX_ERR(0, 769, __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_data = values[0]; + __pyx_v_mode = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("strip_data", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 769, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.strip_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_28strip_data(__pyx_self, __pyx_v_data, __pyx_v_mode); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_28strip_data(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_data, PyObject *__pyx_v_mode) { + 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; + __Pyx_RefNannySetupContext("strip_data", 0); + + /* "analysis.py":771 + * def strip_data(data, mode): + * + * if mode == "adam": # x is the row number, y are the data # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_adam, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 771, __pyx_L1_error) + if (__pyx_t_1) { + } + + /* "analysis.py":774 + * pass + * + * if mode == "eve": # x are the data, y is the column number # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_eve, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 774, __pyx_L1_error) + if (likely(__pyx_t_1)) { + goto __pyx_L4; + } + + /* "analysis.py":778 + * + * else: + * raise error("mode error") # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 778, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __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_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_s_mode_error) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_s_mode_error); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 778, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 778, __pyx_L1_error) + } + __pyx_L4:; + + /* "analysis.py":769 + * + * + * def strip_data(data, mode): # <<<<<<<<<<<<<< + * + * if mode == "adam": # x is the row number, y are the data + */ + + /* 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("analysis.strip_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":782 + * + * # _range in poly regression is the range of powers tried, and in log/exp it is the inverse of the stepsize taken from -1000 to 1000 + * def optimize_regression(x, y, _range, resolution): # <<<<<<<<<<<<<< + * # usage not: for demonstration purpose only, performance is shit + * if type(resolution) != int: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_31optimize_regression(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_31optimize_regression = {"optimize_regression", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_31optimize_regression, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_31optimize_regression(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_x = 0; + PyObject *__pyx_v_y = 0; + PyObject *__pyx_v__range = 0; + PyObject *__pyx_v_resolution = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("optimize_regression (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_range_2,&__pyx_n_s_resolution,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_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("optimize_regression", 1, 4, 4, 1); __PYX_ERR(0, 782, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_range_2)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("optimize_regression", 1, 4, 4, 2); __PYX_ERR(0, 782, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_resolution)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("optimize_regression", 1, 4, 4, 3); __PYX_ERR(0, 782, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "optimize_regression") < 0)) __PYX_ERR(0, 782, __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_x = values[0]; + __pyx_v_y = values[1]; + __pyx_v__range = values[2]; + __pyx_v_resolution = values[3]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("optimize_regression", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 782, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.optimize_regression", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_30optimize_regression(__pyx_self, __pyx_v_x, __pyx_v_y, __pyx_v__range, __pyx_v_resolution); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_30optimize_regression(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y, PyObject *__pyx_v__range, PyObject *__pyx_v_resolution) { + PyObject *__pyx_v_x_train = NULL; + PyObject *__pyx_v_y_train = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_x_test = NULL; + PyObject *__pyx_v_y_test = NULL; + PyObject *__pyx_v_index = NULL; + PyObject *__pyx_v_eqs = NULL; + PyObject *__pyx_v_rmss = NULL; + PyObject *__pyx_v_r2s = NULL; + PyObject *__pyx_v_z = NULL; + PyObject *__pyx_v_overfit = NULL; + 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; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *(*__pyx_t_16)(PyObject *); + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + __Pyx_RefNannySetupContext("optimize_regression", 0); + __Pyx_INCREF(__pyx_v_x); + __Pyx_INCREF(__pyx_v_y); + + /* "analysis.py":784 + * def optimize_regression(x, y, _range, resolution): + * # usage not: for demonstration purpose only, performance is shit + * if type(resolution) != int: # <<<<<<<<<<<<<< + * raise error("resolution must be int") + * + */ + __pyx_t_1 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_resolution)), ((PyObject *)(&PyInt_Type)), Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 784, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 784, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(__pyx_t_2)) { + + /* "analysis.py":785 + * # usage not: for demonstration purpose only, performance is shit + * if type(resolution) != int: + * raise error("resolution must be int") # <<<<<<<<<<<<<< + * + * x_train = x + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 785, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __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_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_s_resolution_must_be_int) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_s_resolution_must_be_int); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 785, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 785, __pyx_L1_error) + + /* "analysis.py":784 + * def optimize_regression(x, y, _range, resolution): + * # usage not: for demonstration purpose only, performance is shit + * if type(resolution) != int: # <<<<<<<<<<<<<< + * raise error("resolution must be int") + * + */ + } + + /* "analysis.py":787 + * raise error("resolution must be int") + * + * x_train = x # <<<<<<<<<<<<<< + * y_train = [] + * + */ + __Pyx_INCREF(__pyx_v_x); + __pyx_v_x_train = __pyx_v_x; + + /* "analysis.py":788 + * + * x_train = x + * y_train = [] # <<<<<<<<<<<<<< + * + * for i in range(len(y)): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 788, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_y_train = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":790 + * y_train = [] + * + * for i in range(len(y)): # <<<<<<<<<<<<<< + * y_train.append(float(y[i])) + * + */ + __pyx_t_5 = PyObject_Length(__pyx_v_y); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 790, __pyx_L1_error) + __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 790, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 790, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_1 = __pyx_t_3; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 790, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 790, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 790, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 790, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 790, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 790, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_6(__pyx_t_1); + 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(0, 790, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":791 + * + * for i in range(len(y)): + * y_train.append(float(y[i])) # <<<<<<<<<<<<<< + * + * x_test = [] + */ + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_y, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 791, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyNumber_Float(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 791, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_y_train, __pyx_t_4); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 791, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "analysis.py":790 + * y_train = [] + * + * for i in range(len(y)): # <<<<<<<<<<<<<< + * y_train.append(float(y[i])) + * + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":793 + * y_train.append(float(y[i])) + * + * x_test = [] # <<<<<<<<<<<<<< + * y_test = [] + * + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 793, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_x_test = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":794 + * + * x_test = [] + * y_test = [] # <<<<<<<<<<<<<< + * + * for i in range(0, math.floor(len(x) * 0.5), 1): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 794, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_y_test = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":796 + * y_test = [] + * + * for i in range(0, math.floor(len(x) * 0.5), 1): # <<<<<<<<<<<<<< + * index = random.randint(0, len(x) - 1) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_math); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_floor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = PyObject_Length(__pyx_v_x); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 796, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble((__pyx_t_5 * 0.5)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_8, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_int_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 796, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 796, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 796, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_6(__pyx_t_3); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 796, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":797 + * + * for i in range(0, math.floor(len(x) * 0.5), 1): + * index = random.randint(0, len(x) - 1) # <<<<<<<<<<<<<< + * + * x_test.append(x[index]) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_random); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 797, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_randint); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 797, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_9 = PyObject_Length(__pyx_v_x); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 797, __pyx_L1_error) + __pyx_t_4 = PyInt_FromSsize_t((__pyx_t_9 - 1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 797, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_10 = NULL; + __pyx_t_11 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_11 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_int_0, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 797, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_int_0, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 797, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_12 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 797, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (__pyx_t_10) { + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_10); __pyx_t_10 = NULL; + } + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_11, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_11, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_12, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 797, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":799 + * index = random.randint(0, len(x) - 1) + * + * x_test.append(x[index]) # <<<<<<<<<<<<<< + * y_test.append(float(y[index])) + * + */ + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_x, __pyx_v_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 799, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_x_test, __pyx_t_1); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 799, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":800 + * + * x_test.append(x[index]) + * y_test.append(float(y[index])) # <<<<<<<<<<<<<< + * + * x_train.pop(index) + */ + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_y, __pyx_v_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 800, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyNumber_Float(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 800, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_y_test, __pyx_t_8); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 800, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "analysis.py":802 + * y_test.append(float(y[index])) + * + * x_train.pop(index) # <<<<<<<<<<<<<< + * y_train.pop(index) + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_x_train, __pyx_n_s_pop); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 802, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_12 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_8 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_12, __pyx_v_index) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_index); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 802, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "analysis.py":803 + * + * x_train.pop(index) + * y_train.pop(index) # <<<<<<<<<<<<<< + * + * #print(x_train, x_test) + */ + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 803, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyList_PopIndex(__pyx_v_y_train, __pyx_v_index, __pyx_t_9, 1, Py_ssize_t, PyInt_FromSsize_t); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 803, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "analysis.py":796 + * y_test = [] + * + * for i in range(0, math.floor(len(x) * 0.5), 1): # <<<<<<<<<<<<<< + * index = random.randint(0, len(x) - 1) + * + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "analysis.py":808 + * #print(y_train, y_test) + * + * eqs = [] # <<<<<<<<<<<<<< + * rmss = [] + * r2s = [] + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 808, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_eqs = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":809 + * + * eqs = [] + * rmss = [] # <<<<<<<<<<<<<< + * r2s = [] + * + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 809, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rmss = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":810 + * eqs = [] + * rmss = [] + * r2s = [] # <<<<<<<<<<<<<< + * + * for i in range(0, _range + 1, 1): + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 810, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_r2s = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":812 + * r2s = [] + * + * for i in range(0, _range + 1, 1): # <<<<<<<<<<<<<< + * try: + * x, y, z = poly_regression(x_train, y_train, i) + */ + __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v__range, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 812, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 812, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_int_1); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 812, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_8 = __pyx_t_3; __Pyx_INCREF(__pyx_t_8); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 812, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = Py_TYPE(__pyx_t_8)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 812, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_8))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_8)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 812, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 812, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_8)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 812, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 812, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_6(__pyx_t_8); + 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(0, 812, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":813 + * + * for i in range(0, _range + 1, 1): + * try: # <<<<<<<<<<<<<< + * x, y, z = poly_regression(x_train, y_train, i) + * eqs.append(x) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_15); + /*try:*/ { + + /* "analysis.py":814 + * for i in range(0, _range + 1, 1): + * try: + * x, y, z = poly_regression(x_train, y_train, i) # <<<<<<<<<<<<<< + * eqs.append(x) + * rmss.append(y) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_poly_regression); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 814, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_12 = NULL; + __pyx_t_11 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_11 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[4] = {__pyx_t_12, __pyx_v_x_train, __pyx_v_y_train, __pyx_v_i}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 814, __pyx_L10_error) + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[4] = {__pyx_t_12, __pyx_v_x_train, __pyx_v_y_train, __pyx_v_i}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 814, __pyx_L10_error) + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_4 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 814, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_12) { + __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_12); __pyx_t_12 = NULL; + } + __Pyx_INCREF(__pyx_v_x_train); + __Pyx_GIVEREF(__pyx_v_x_train); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_11, __pyx_v_x_train); + __Pyx_INCREF(__pyx_v_y_train); + __Pyx_GIVEREF(__pyx_v_y_train); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_11, __pyx_v_y_train); + __Pyx_INCREF(__pyx_v_i); + __Pyx_GIVEREF(__pyx_v_i); + PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_11, __pyx_v_i); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 814, __pyx_L10_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 ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + 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(0, 814, __pyx_L10_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_4 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_12 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_1 = PyList_GET_ITEM(sequence, 0); + __pyx_t_4 = PyList_GET_ITEM(sequence, 1); + __pyx_t_12 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_12); + #else + __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 814, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 814, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 814, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_12); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_10 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 814, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_16 = Py_TYPE(__pyx_t_10)->tp_iternext; + index = 0; __pyx_t_1 = __pyx_t_16(__pyx_t_10); if (unlikely(!__pyx_t_1)) goto __pyx_L18_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + index = 1; __pyx_t_4 = __pyx_t_16(__pyx_t_10); if (unlikely(!__pyx_t_4)) goto __pyx_L18_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 2; __pyx_t_12 = __pyx_t_16(__pyx_t_10); if (unlikely(!__pyx_t_12)) goto __pyx_L18_unpacking_failed; + __Pyx_GOTREF(__pyx_t_12); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_10), 3) < 0) __PYX_ERR(0, 814, __pyx_L10_error) + __pyx_t_16 = NULL; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + goto __pyx_L19_unpacking_done; + __pyx_L18_unpacking_failed:; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_16 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 814, __pyx_L10_error) + __pyx_L19_unpacking_done:; + } + __Pyx_DECREF_SET(__pyx_v_x, __pyx_t_1); + __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_z, __pyx_t_12); + __pyx_t_12 = 0; + + /* "analysis.py":815 + * try: + * x, y, z = poly_regression(x_train, y_train, i) + * eqs.append(x) # <<<<<<<<<<<<<< + * rmss.append(y) + * r2s.append(z) + */ + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_eqs, __pyx_v_x); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 815, __pyx_L10_error) + + /* "analysis.py":816 + * x, y, z = poly_regression(x_train, y_train, i) + * eqs.append(x) + * rmss.append(y) # <<<<<<<<<<<<<< + * r2s.append(z) + * except: + */ + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_rmss, __pyx_v_y); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 816, __pyx_L10_error) + + /* "analysis.py":817 + * eqs.append(x) + * rmss.append(y) + * r2s.append(z) # <<<<<<<<<<<<<< + * except: + * pass + */ + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_r2s, __pyx_v_z); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 817, __pyx_L10_error) + + /* "analysis.py":813 + * + * for i in range(0, _range + 1, 1): + * try: # <<<<<<<<<<<<<< + * x, y, z = poly_regression(x_train, y_train, i) + * eqs.append(x) + */ + } + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + goto __pyx_L17_try_end; + __pyx_L10_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "analysis.py":818 + * rmss.append(y) + * r2s.append(z) + * except: # <<<<<<<<<<<<<< + * pass + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L11_exception_handled; + } + __pyx_L11_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15); + __pyx_L17_try_end:; + } + + /* "analysis.py":812 + * r2s = [] + * + * for i in range(0, _range + 1, 1): # <<<<<<<<<<<<<< + * try: + * x, y, z = poly_regression(x_train, y_train, i) + */ + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "analysis.py":821 + * pass + * + * for i in range(1, 100 * resolution + 1): # <<<<<<<<<<<<<< + * try: + * x, y, z = exp_regression(x_train, y_train, float(i / resolution)) + */ + __pyx_t_8 = PyNumber_Multiply(__pyx_int_100, __pyx_v_resolution); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_t_8, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_int_1); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_8 = __pyx_t_3; __Pyx_INCREF(__pyx_t_8); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = Py_TYPE(__pyx_t_8)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 821, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_8))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_8)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 821, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_8)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 821, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_6(__pyx_t_8); + 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(0, 821, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":822 + * + * for i in range(1, 100 * resolution + 1): + * try: # <<<<<<<<<<<<<< + * x, y, z = exp_regression(x_train, y_train, float(i / resolution)) + * eqs.append(x) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_15, &__pyx_t_14, &__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_13); + /*try:*/ { + + /* "analysis.py":823 + * for i in range(1, 100 * resolution + 1): + * try: + * x, y, z = exp_regression(x_train, y_train, float(i / resolution)) # <<<<<<<<<<<<<< + * eqs.append(x) + * rmss.append(y) + */ + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_exp_regression); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 823, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_i, __pyx_v_resolution); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 823, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyNumber_Float(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 823, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_11 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_12); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_12, function); + __pyx_t_11 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_12)) { + PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_x_train, __pyx_v_y_train, __pyx_t_1}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_12, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 823, __pyx_L22_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_12)) { + PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_x_train, __pyx_v_y_train, __pyx_t_1}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_12, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 823, __pyx_L22_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 823, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(__pyx_v_x_train); + __Pyx_GIVEREF(__pyx_v_x_train); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_11, __pyx_v_x_train); + __Pyx_INCREF(__pyx_v_y_train); + __Pyx_GIVEREF(__pyx_v_y_train); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_11, __pyx_v_y_train); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_11, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 823, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + 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(0, 823, __pyx_L22_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_12 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_10 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_12 = PyList_GET_ITEM(sequence, 0); + __pyx_t_10 = PyList_GET_ITEM(sequence, 1); + __pyx_t_1 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(__pyx_t_1); + #else + __pyx_t_12 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 823, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_10 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 823, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_1 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 823, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_4 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 823, __pyx_L22_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_16 = Py_TYPE(__pyx_t_4)->tp_iternext; + index = 0; __pyx_t_12 = __pyx_t_16(__pyx_t_4); if (unlikely(!__pyx_t_12)) goto __pyx_L30_unpacking_failed; + __Pyx_GOTREF(__pyx_t_12); + index = 1; __pyx_t_10 = __pyx_t_16(__pyx_t_4); if (unlikely(!__pyx_t_10)) goto __pyx_L30_unpacking_failed; + __Pyx_GOTREF(__pyx_t_10); + index = 2; __pyx_t_1 = __pyx_t_16(__pyx_t_4); if (unlikely(!__pyx_t_1)) goto __pyx_L30_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_4), 3) < 0) __PYX_ERR(0, 823, __pyx_L22_error) + __pyx_t_16 = NULL; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L31_unpacking_done; + __pyx_L30_unpacking_failed:; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_16 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 823, __pyx_L22_error) + __pyx_L31_unpacking_done:; + } + __Pyx_DECREF_SET(__pyx_v_x, __pyx_t_12); + __pyx_t_12 = 0; + __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_10); + __pyx_t_10 = 0; + __Pyx_XDECREF_SET(__pyx_v_z, __pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":824 + * try: + * x, y, z = exp_regression(x_train, y_train, float(i / resolution)) + * eqs.append(x) # <<<<<<<<<<<<<< + * rmss.append(y) + * r2s.append(z) + */ + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_eqs, __pyx_v_x); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 824, __pyx_L22_error) + + /* "analysis.py":825 + * x, y, z = exp_regression(x_train, y_train, float(i / resolution)) + * eqs.append(x) + * rmss.append(y) # <<<<<<<<<<<<<< + * r2s.append(z) + * except: + */ + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_rmss, __pyx_v_y); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 825, __pyx_L22_error) + + /* "analysis.py":826 + * eqs.append(x) + * rmss.append(y) + * r2s.append(z) # <<<<<<<<<<<<<< + * except: + * pass + */ + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_r2s, __pyx_v_z); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 826, __pyx_L22_error) + + /* "analysis.py":822 + * + * for i in range(1, 100 * resolution + 1): + * try: # <<<<<<<<<<<<<< + * x, y, z = exp_regression(x_train, y_train, float(i / resolution)) + * eqs.append(x) + */ + } + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + goto __pyx_L29_try_end; + __pyx_L22_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "analysis.py":827 + * rmss.append(y) + * r2s.append(z) + * except: # <<<<<<<<<<<<<< + * pass + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L23_exception_handled; + } + __pyx_L23_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_14, __pyx_t_13); + __pyx_L29_try_end:; + } + + /* "analysis.py":821 + * pass + * + * for i in range(1, 100 * resolution + 1): # <<<<<<<<<<<<<< + * try: + * x, y, z = exp_regression(x_train, y_train, float(i / resolution)) + */ + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "analysis.py":830 + * pass + * + * for i in range(1, 100 * resolution + 1): # <<<<<<<<<<<<<< + * try: + * x, y, z = log_regression(x_train, y_train, float(i / resolution)) + */ + __pyx_t_8 = PyNumber_Multiply(__pyx_int_100, __pyx_v_resolution); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_t_8, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_int_1); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_8 = __pyx_t_3; __Pyx_INCREF(__pyx_t_8); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = Py_TYPE(__pyx_t_8)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 830, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_8))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_8)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 830, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_8)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 830, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_6(__pyx_t_8); + 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(0, 830, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":831 + * + * for i in range(1, 100 * resolution + 1): + * try: # <<<<<<<<<<<<<< + * x, y, z = log_regression(x_train, y_train, float(i / resolution)) + * eqs.append(x) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_15); + /*try:*/ { + + /* "analysis.py":832 + * for i in range(1, 100 * resolution + 1): + * try: + * x, y, z = log_regression(x_train, y_train, float(i / resolution)) # <<<<<<<<<<<<<< + * eqs.append(x) + * rmss.append(y) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_log_regression); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 832, __pyx_L34_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_10 = __Pyx_PyNumber_Divide(__pyx_v_i, __pyx_v_resolution); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 832, __pyx_L34_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_12 = __Pyx_PyNumber_Float(__pyx_t_10); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 832, __pyx_L34_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = NULL; + __pyx_t_11 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_11 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_v_x_train, __pyx_v_y_train, __pyx_t_12}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 832, __pyx_L34_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_v_x_train, __pyx_v_y_train, __pyx_t_12}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 832, __pyx_L34_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 832, __pyx_L34_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_10) { + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_10); __pyx_t_10 = NULL; + } + __Pyx_INCREF(__pyx_v_x_train); + __Pyx_GIVEREF(__pyx_v_x_train); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_11, __pyx_v_x_train); + __Pyx_INCREF(__pyx_v_y_train); + __Pyx_GIVEREF(__pyx_v_y_train); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_11, __pyx_v_y_train); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_11, __pyx_t_12); + __pyx_t_12 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 832, __pyx_L34_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 ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + 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(0, 832, __pyx_L34_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_4 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_12 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_1 = PyList_GET_ITEM(sequence, 0); + __pyx_t_4 = PyList_GET_ITEM(sequence, 1); + __pyx_t_12 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_12); + #else + __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 832, __pyx_L34_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 832, __pyx_L34_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 832, __pyx_L34_error) + __Pyx_GOTREF(__pyx_t_12); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_10 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 832, __pyx_L34_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_16 = Py_TYPE(__pyx_t_10)->tp_iternext; + index = 0; __pyx_t_1 = __pyx_t_16(__pyx_t_10); if (unlikely(!__pyx_t_1)) goto __pyx_L42_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + index = 1; __pyx_t_4 = __pyx_t_16(__pyx_t_10); if (unlikely(!__pyx_t_4)) goto __pyx_L42_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 2; __pyx_t_12 = __pyx_t_16(__pyx_t_10); if (unlikely(!__pyx_t_12)) goto __pyx_L42_unpacking_failed; + __Pyx_GOTREF(__pyx_t_12); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_10), 3) < 0) __PYX_ERR(0, 832, __pyx_L34_error) + __pyx_t_16 = NULL; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + goto __pyx_L43_unpacking_done; + __pyx_L42_unpacking_failed:; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_16 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 832, __pyx_L34_error) + __pyx_L43_unpacking_done:; + } + __Pyx_DECREF_SET(__pyx_v_x, __pyx_t_1); + __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_z, __pyx_t_12); + __pyx_t_12 = 0; + + /* "analysis.py":833 + * try: + * x, y, z = log_regression(x_train, y_train, float(i / resolution)) + * eqs.append(x) # <<<<<<<<<<<<<< + * rmss.append(y) + * r2s.append(z) + */ + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_eqs, __pyx_v_x); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 833, __pyx_L34_error) + + /* "analysis.py":834 + * x, y, z = log_regression(x_train, y_train, float(i / resolution)) + * eqs.append(x) + * rmss.append(y) # <<<<<<<<<<<<<< + * r2s.append(z) + * except: + */ + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_rmss, __pyx_v_y); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 834, __pyx_L34_error) + + /* "analysis.py":835 + * eqs.append(x) + * rmss.append(y) + * r2s.append(z) # <<<<<<<<<<<<<< + * except: + * pass + */ + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_r2s, __pyx_v_z); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 835, __pyx_L34_error) + + /* "analysis.py":831 + * + * for i in range(1, 100 * resolution + 1): + * try: # <<<<<<<<<<<<<< + * x, y, z = log_regression(x_train, y_train, float(i / resolution)) + * eqs.append(x) + */ + } + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + goto __pyx_L41_try_end; + __pyx_L34_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "analysis.py":836 + * rmss.append(y) + * r2s.append(z) + * except: # <<<<<<<<<<<<<< + * pass + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L35_exception_handled; + } + __pyx_L35_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15); + __pyx_L41_try_end:; + } + + /* "analysis.py":830 + * pass + * + * for i in range(1, 100 * resolution + 1): # <<<<<<<<<<<<<< + * try: + * x, y, z = log_regression(x_train, y_train, float(i / resolution)) + */ + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "analysis.py":839 + * pass + * + * try: # <<<<<<<<<<<<<< + * x, y, z = tanh_regression(x_train, y_train) + * + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_15, &__pyx_t_14, &__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_13); + /*try:*/ { + + /* "analysis.py":840 + * + * try: + * x, y, z = tanh_regression(x_train, y_train) # <<<<<<<<<<<<<< + * + * eqs.append(x) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_tanh_regression); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 840, __pyx_L44_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_12 = NULL; + __pyx_t_11 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_11 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_v_x_train, __pyx_v_y_train}; + __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 840, __pyx_L44_error) + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GOTREF(__pyx_t_8); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_v_x_train, __pyx_v_y_train}; + __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 840, __pyx_L44_error) + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GOTREF(__pyx_t_8); + } else + #endif + { + __pyx_t_4 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 840, __pyx_L44_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_12) { + __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_12); __pyx_t_12 = NULL; + } + __Pyx_INCREF(__pyx_v_x_train); + __Pyx_GIVEREF(__pyx_v_x_train); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_11, __pyx_v_x_train); + __Pyx_INCREF(__pyx_v_y_train); + __Pyx_GIVEREF(__pyx_v_y_train); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_11, __pyx_v_y_train); + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 840, __pyx_L44_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) { + PyObject* sequence = __pyx_t_8; + 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(0, 840, __pyx_L44_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); + __pyx_t_12 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_3 = PyList_GET_ITEM(sequence, 0); + __pyx_t_4 = PyList_GET_ITEM(sequence, 1); + __pyx_t_12 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_12); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 840, __pyx_L44_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 840, __pyx_L44_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 840, __pyx_L44_error) + __Pyx_GOTREF(__pyx_t_12); + #endif + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_1 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 840, __pyx_L44_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_16 = Py_TYPE(__pyx_t_1)->tp_iternext; + index = 0; __pyx_t_3 = __pyx_t_16(__pyx_t_1); if (unlikely(!__pyx_t_3)) goto __pyx_L50_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + index = 1; __pyx_t_4 = __pyx_t_16(__pyx_t_1); if (unlikely(!__pyx_t_4)) goto __pyx_L50_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 2; __pyx_t_12 = __pyx_t_16(__pyx_t_1); if (unlikely(!__pyx_t_12)) goto __pyx_L50_unpacking_failed; + __Pyx_GOTREF(__pyx_t_12); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_1), 3) < 0) __PYX_ERR(0, 840, __pyx_L44_error) + __pyx_t_16 = NULL; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L51_unpacking_done; + __pyx_L50_unpacking_failed:; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_16 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 840, __pyx_L44_error) + __pyx_L51_unpacking_done:; + } + __Pyx_DECREF_SET(__pyx_v_x, __pyx_t_3); + __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_z, __pyx_t_12); + __pyx_t_12 = 0; + + /* "analysis.py":842 + * x, y, z = tanh_regression(x_train, y_train) + * + * eqs.append(x) # <<<<<<<<<<<<<< + * rmss.append(y) + * r2s.append(z) + */ + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_eqs, __pyx_v_x); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 842, __pyx_L44_error) + + /* "analysis.py":843 + * + * eqs.append(x) + * rmss.append(y) # <<<<<<<<<<<<<< + * r2s.append(z) + * except: + */ + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_rmss, __pyx_v_y); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 843, __pyx_L44_error) + + /* "analysis.py":844 + * eqs.append(x) + * rmss.append(y) + * r2s.append(z) # <<<<<<<<<<<<<< + * except: + * pass + */ + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_r2s, __pyx_v_z); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 844, __pyx_L44_error) + + /* "analysis.py":839 + * pass + * + * try: # <<<<<<<<<<<<<< + * x, y, z = tanh_regression(x_train, y_train) + * + */ + } + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + goto __pyx_L49_try_end; + __pyx_L44_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "analysis.py":845 + * rmss.append(y) + * r2s.append(z) + * except: # <<<<<<<<<<<<<< + * pass + * + */ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L45_exception_handled; + } + __pyx_L45_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_14, __pyx_t_13); + __pyx_L49_try_end:; + } + + /* "analysis.py":849 + * + * # marks all equations where r2 = 1 as they 95% of the time overfit the data + * for i in range(0, len(eqs), 1): # <<<<<<<<<<<<<< + * if r2s[i] == 1: + * eqs[i] = "" + */ + __pyx_t_5 = PyList_GET_SIZE(__pyx_v_eqs); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 849, __pyx_L1_error) + __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 849, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_12 = PyTuple_New(3); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 849, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_8); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_12, 2, __pyx_int_1); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 849, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (likely(PyList_CheckExact(__pyx_t_8)) || PyTuple_CheckExact(__pyx_t_8)) { + __pyx_t_12 = __pyx_t_8; __Pyx_INCREF(__pyx_t_12); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_12 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 849, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_6 = Py_TYPE(__pyx_t_12)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 849, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_12))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_12)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyList_GET_ITEM(__pyx_t_12, __pyx_t_5); __Pyx_INCREF(__pyx_t_8); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 849, __pyx_L1_error) + #else + __pyx_t_8 = PySequence_ITEM(__pyx_t_12, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 849, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_12)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_12, __pyx_t_5); __Pyx_INCREF(__pyx_t_8); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 849, __pyx_L1_error) + #else + __pyx_t_8 = PySequence_ITEM(__pyx_t_12, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 849, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } + } else { + __pyx_t_8 = __pyx_t_6(__pyx_t_12); + if (unlikely(!__pyx_t_8)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 849, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_8); + __pyx_t_8 = 0; + + /* "analysis.py":850 + * # marks all equations where r2 = 1 as they 95% of the time overfit the data + * for i in range(0, len(eqs), 1): + * if r2s[i] == 1: # <<<<<<<<<<<<<< + * eqs[i] = "" + * rmss[i] = "" + */ + __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_r2s, __pyx_v_i); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 850, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_8, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 850, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 850, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_2) { + + /* "analysis.py":851 + * for i in range(0, len(eqs), 1): + * if r2s[i] == 1: + * eqs[i] = "" # <<<<<<<<<<<<<< + * rmss[i] = "" + * r2s[i] = "" + */ + if (unlikely(PyObject_SetItem(__pyx_v_eqs, __pyx_v_i, __pyx_kp_s__2) < 0)) __PYX_ERR(0, 851, __pyx_L1_error) + + /* "analysis.py":852 + * if r2s[i] == 1: + * eqs[i] = "" + * rmss[i] = "" # <<<<<<<<<<<<<< + * r2s[i] = "" + * + */ + if (unlikely(PyObject_SetItem(__pyx_v_rmss, __pyx_v_i, __pyx_kp_s__2) < 0)) __PYX_ERR(0, 852, __pyx_L1_error) + + /* "analysis.py":853 + * eqs[i] = "" + * rmss[i] = "" + * r2s[i] = "" # <<<<<<<<<<<<<< + * + * while True: # removes all equations marked for removal + */ + if (unlikely(PyObject_SetItem(__pyx_v_r2s, __pyx_v_i, __pyx_kp_s__2) < 0)) __PYX_ERR(0, 853, __pyx_L1_error) + + /* "analysis.py":850 + * # marks all equations where r2 = 1 as they 95% of the time overfit the data + * for i in range(0, len(eqs), 1): + * if r2s[i] == 1: # <<<<<<<<<<<<<< + * eqs[i] = "" + * rmss[i] = "" + */ + } + + /* "analysis.py":849 + * + * # marks all equations where r2 = 1 as they 95% of the time overfit the data + * for i in range(0, len(eqs), 1): # <<<<<<<<<<<<<< + * if r2s[i] == 1: + * eqs[i] = "" + */ + } + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + /* "analysis.py":855 + * r2s[i] = "" + * + * while True: # removes all equations marked for removal # <<<<<<<<<<<<<< + * try: + * eqs.remove('') + */ + while (1) { + + /* "analysis.py":856 + * + * while True: # removes all equations marked for removal + * try: # <<<<<<<<<<<<<< + * eqs.remove('') + * rmss.remove('') + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_15); + /*try:*/ { + + /* "analysis.py":857 + * while True: # removes all equations marked for removal + * try: + * eqs.remove('') # <<<<<<<<<<<<<< + * rmss.remove('') + * r2s.remove('') + */ + __pyx_t_12 = __Pyx_CallUnboundCMethod1(&__pyx_umethod_PyList_Type_remove, __pyx_v_eqs, __pyx_kp_s__2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 857, __pyx_L57_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + /* "analysis.py":858 + * try: + * eqs.remove('') + * rmss.remove('') # <<<<<<<<<<<<<< + * r2s.remove('') + * except: + */ + __pyx_t_12 = __Pyx_CallUnboundCMethod1(&__pyx_umethod_PyList_Type_remove, __pyx_v_rmss, __pyx_kp_s__2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 858, __pyx_L57_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + /* "analysis.py":859 + * eqs.remove('') + * rmss.remove('') + * r2s.remove('') # <<<<<<<<<<<<<< + * except: + * break + */ + __pyx_t_12 = __Pyx_CallUnboundCMethod1(&__pyx_umethod_PyList_Type_remove, __pyx_v_r2s, __pyx_kp_s__2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 859, __pyx_L57_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + /* "analysis.py":856 + * + * while True: # removes all equations marked for removal + * try: # <<<<<<<<<<<<<< + * eqs.remove('') + * rmss.remove('') + */ + } + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + goto __pyx_L64_try_end; + __pyx_L57_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "analysis.py":860 + * rmss.remove('') + * r2s.remove('') + * except: # <<<<<<<<<<<<<< + * break + * + */ + /*except:*/ { + __Pyx_AddTraceback("analysis.optimize_regression", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_4, &__pyx_t_8) < 0) __PYX_ERR(0, 860, __pyx_L59_except_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_t_8); + + /* "analysis.py":861 + * r2s.remove('') + * except: + * break # <<<<<<<<<<<<<< + * + * overfit = [] + */ + goto __pyx_L65_except_break; + __pyx_L65_except_break:; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L62_try_break; + } + __pyx_L59_except_error:; + + /* "analysis.py":856 + * + * while True: # removes all equations marked for removal + * try: # <<<<<<<<<<<<<< + * eqs.remove('') + * rmss.remove('') + */ + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15); + goto __pyx_L1_error; + __pyx_L62_try_break:; + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15); + goto __pyx_L56_break; + __pyx_L64_try_end:; + } + } + __pyx_L56_break:; + + /* "analysis.py":863 + * break + * + * overfit = [] # <<<<<<<<<<<<<< + * + * for i in range(0, len(eqs), 1): + */ + __pyx_t_8 = PyList_New(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 863, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_v_overfit = ((PyObject*)__pyx_t_8); + __pyx_t_8 = 0; + + /* "analysis.py":865 + * overfit = [] + * + * for i in range(0, len(eqs), 1): # <<<<<<<<<<<<<< + * + * overfit.append(calc_overfit(eqs[i], rmss[i], r2s[i], x_test, y_test)) + */ + __pyx_t_5 = PyList_GET_SIZE(__pyx_v_eqs); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 865, __pyx_L1_error) + __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_8); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_int_1); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_4, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (likely(PyList_CheckExact(__pyx_t_8)) || PyTuple_CheckExact(__pyx_t_8)) { + __pyx_t_4 = __pyx_t_8; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 865, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_8); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 865, __pyx_L1_error) + #else + __pyx_t_8 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_8); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 865, __pyx_L1_error) + #else + __pyx_t_8 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } + } else { + __pyx_t_8 = __pyx_t_6(__pyx_t_4); + if (unlikely(!__pyx_t_8)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 865, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_8); + __pyx_t_8 = 0; + + /* "analysis.py":867 + * for i in range(0, len(eqs), 1): + * + * overfit.append(calc_overfit(eqs[i], rmss[i], r2s[i], x_test, y_test)) # <<<<<<<<<<<<<< + * + * return eqs, rmss, r2s, overfit + */ + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_calc_overfit); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_eqs, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_rmss, __pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_10 = __Pyx_PyObject_GetItem(__pyx_v_r2s, __pyx_v_i); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_17 = NULL; + __pyx_t_11 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_12); + if (likely(__pyx_t_17)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_17); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_12, function); + __pyx_t_11 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_12)) { + PyObject *__pyx_temp[6] = {__pyx_t_17, __pyx_t_3, __pyx_t_1, __pyx_t_10, __pyx_v_x_test, __pyx_v_y_test}; + __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_12, __pyx_temp+1-__pyx_t_11, 5+__pyx_t_11); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 867, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_12)) { + PyObject *__pyx_temp[6] = {__pyx_t_17, __pyx_t_3, __pyx_t_1, __pyx_t_10, __pyx_v_x_test, __pyx_v_y_test}; + __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_12, __pyx_temp+1-__pyx_t_11, 5+__pyx_t_11); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 867, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + { + __pyx_t_18 = PyTuple_New(5+__pyx_t_11); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + if (__pyx_t_17) { + __Pyx_GIVEREF(__pyx_t_17); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_17); __pyx_t_17 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_18, 0+__pyx_t_11, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_18, 1+__pyx_t_11, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_18, 2+__pyx_t_11, __pyx_t_10); + __Pyx_INCREF(__pyx_v_x_test); + __Pyx_GIVEREF(__pyx_v_x_test); + PyTuple_SET_ITEM(__pyx_t_18, 3+__pyx_t_11, __pyx_v_x_test); + __Pyx_INCREF(__pyx_v_y_test); + __Pyx_GIVEREF(__pyx_v_y_test); + PyTuple_SET_ITEM(__pyx_t_18, 4+__pyx_t_11, __pyx_v_y_test); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_t_10 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_18, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + } + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_overfit, __pyx_t_8); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 867, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "analysis.py":865 + * overfit = [] + * + * for i in range(0, len(eqs), 1): # <<<<<<<<<<<<<< + * + * overfit.append(calc_overfit(eqs[i], rmss[i], r2s[i], x_test, y_test)) + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "analysis.py":869 + * overfit.append(calc_overfit(eqs[i], rmss[i], r2s[i], x_test, y_test)) + * + * return eqs, rmss, r2s, overfit # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 869, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_eqs); + __Pyx_GIVEREF(__pyx_v_eqs); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_eqs); + __Pyx_INCREF(__pyx_v_rmss); + __Pyx_GIVEREF(__pyx_v_rmss); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_rmss); + __Pyx_INCREF(__pyx_v_r2s); + __Pyx_GIVEREF(__pyx_v_r2s); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_r2s); + __Pyx_INCREF(__pyx_v_overfit); + __Pyx_GIVEREF(__pyx_v_overfit); + PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_overfit); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "analysis.py":782 + * + * # _range in poly regression is the range of powers tried, and in log/exp it is the inverse of the stepsize taken from -1000 to 1000 + * def optimize_regression(x, y, _range, resolution): # <<<<<<<<<<<<<< + * # usage not: for demonstration purpose only, performance is shit + * if type(resolution) != int: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_AddTraceback("analysis.optimize_regression", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_x_train); + __Pyx_XDECREF(__pyx_v_y_train); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_x_test); + __Pyx_XDECREF(__pyx_v_y_test); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_XDECREF(__pyx_v_eqs); + __Pyx_XDECREF(__pyx_v_rmss); + __Pyx_XDECREF(__pyx_v_r2s); + __Pyx_XDECREF(__pyx_v_z); + __Pyx_XDECREF(__pyx_v_overfit); + __Pyx_XDECREF(__pyx_v_x); + __Pyx_XDECREF(__pyx_v_y); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":872 + * + * + * def select_best_regression(eqs, rmss, r2s, overfit, selector): # <<<<<<<<<<<<<< + * + * b_eq = "" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_33select_best_regression(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_33select_best_regression = {"select_best_regression", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_33select_best_regression, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_33select_best_regression(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_eqs = 0; + PyObject *__pyx_v_rmss = 0; + PyObject *__pyx_v_r2s = 0; + PyObject *__pyx_v_overfit = 0; + PyObject *__pyx_v_selector = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("select_best_regression (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_eqs,&__pyx_n_s_rmss,&__pyx_n_s_r2s,&__pyx_n_s_overfit,&__pyx_n_s_selector,0}; + PyObject* values[5] = {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 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_eqs)) != 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_rmss)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("select_best_regression", 1, 5, 5, 1); __PYX_ERR(0, 872, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_r2s)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("select_best_regression", 1, 5, 5, 2); __PYX_ERR(0, 872, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_overfit)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("select_best_regression", 1, 5, 5, 3); __PYX_ERR(0, 872, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_selector)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("select_best_regression", 1, 5, 5, 4); __PYX_ERR(0, 872, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "select_best_regression") < 0)) __PYX_ERR(0, 872, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { + 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); + } + __pyx_v_eqs = values[0]; + __pyx_v_rmss = values[1]; + __pyx_v_r2s = values[2]; + __pyx_v_overfit = values[3]; + __pyx_v_selector = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("select_best_regression", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 872, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.select_best_regression", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_32select_best_regression(__pyx_self, __pyx_v_eqs, __pyx_v_rmss, __pyx_v_r2s, __pyx_v_overfit, __pyx_v_selector); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_32select_best_regression(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_eqs, PyObject *__pyx_v_rmss, PyObject *__pyx_v_r2s, PyObject *__pyx_v_overfit, PyObject *__pyx_v_selector) { + PyObject *__pyx_v_b_eq = NULL; + PyObject *__pyx_v_b_rms = NULL; + PyObject *__pyx_v_b_r2 = NULL; + PyObject *__pyx_v_b_overfit = NULL; + PyObject *__pyx_v_ind = 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; + __Pyx_RefNannySetupContext("select_best_regression", 0); + + /* "analysis.py":874 + * def select_best_regression(eqs, rmss, r2s, overfit, selector): + * + * b_eq = "" # <<<<<<<<<<<<<< + * b_rms = 0 + * b_r2 = 0 + */ + __Pyx_INCREF(__pyx_kp_s__2); + __pyx_v_b_eq = __pyx_kp_s__2; + + /* "analysis.py":875 + * + * b_eq = "" + * b_rms = 0 # <<<<<<<<<<<<<< + * b_r2 = 0 + * b_overfit = 0 + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_v_b_rms = __pyx_int_0; + + /* "analysis.py":876 + * b_eq = "" + * b_rms = 0 + * b_r2 = 0 # <<<<<<<<<<<<<< + * b_overfit = 0 + * + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_v_b_r2 = __pyx_int_0; + + /* "analysis.py":877 + * b_rms = 0 + * b_r2 = 0 + * b_overfit = 0 # <<<<<<<<<<<<<< + * + * ind = 0 + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_v_b_overfit = __pyx_int_0; + + /* "analysis.py":879 + * b_overfit = 0 + * + * ind = 0 # <<<<<<<<<<<<<< + * + * if selector == "min_overfit": + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_v_ind = __pyx_int_0; + + /* "analysis.py":881 + * ind = 0 + * + * if selector == "min_overfit": # <<<<<<<<<<<<<< + * + * ind = np.argmin(overfit) + */ + __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_selector, __pyx_n_s_min_overfit, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 881, __pyx_L1_error) + if (__pyx_t_1) { + + /* "analysis.py":883 + * if selector == "min_overfit": + * + * ind = np.argmin(overfit) # <<<<<<<<<<<<<< + * + * b_eq = eqs[ind] + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 883, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_argmin); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 883, __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 && unlikely(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_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_3, __pyx_v_overfit) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_overfit); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 883, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_ind, __pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":885 + * ind = np.argmin(overfit) + * + * b_eq = eqs[ind] # <<<<<<<<<<<<<< + * b_rms = rmss[ind] + * b_r2 = r2s[ind] + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_eqs, __pyx_v_ind); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_b_eq, __pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":886 + * + * b_eq = eqs[ind] + * b_rms = rmss[ind] # <<<<<<<<<<<<<< + * b_r2 = r2s[ind] + * b_overfit = overfit[ind] + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_rmss, __pyx_v_ind); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 886, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_b_rms, __pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":887 + * b_eq = eqs[ind] + * b_rms = rmss[ind] + * b_r2 = r2s[ind] # <<<<<<<<<<<<<< + * b_overfit = overfit[ind] + * + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_r2s, __pyx_v_ind); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 887, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_b_r2, __pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":888 + * b_rms = rmss[ind] + * b_r2 = r2s[ind] + * b_overfit = overfit[ind] # <<<<<<<<<<<<<< + * + * if selector == "max_r2s": + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_overfit, __pyx_v_ind); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 888, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_b_overfit, __pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":881 + * ind = 0 + * + * if selector == "min_overfit": # <<<<<<<<<<<<<< + * + * ind = np.argmin(overfit) + */ + } + + /* "analysis.py":890 + * b_overfit = overfit[ind] + * + * if selector == "max_r2s": # <<<<<<<<<<<<<< + * + * ind = np.argmax(r2s) + */ + __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_selector, __pyx_n_s_max_r2s, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 890, __pyx_L1_error) + if (__pyx_t_1) { + + /* "analysis.py":892 + * if selector == "max_r2s": + * + * ind = np.argmax(r2s) # <<<<<<<<<<<<<< + * b_eq = eqs[ind] + * b_rms = rmss[ind] + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_argmax); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 892, __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 && 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_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_r2s) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_r2s); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_ind, __pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":893 + * + * ind = np.argmax(r2s) + * b_eq = eqs[ind] # <<<<<<<<<<<<<< + * b_rms = rmss[ind] + * b_r2 = r2s[ind] + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_eqs, __pyx_v_ind); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 893, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_b_eq, __pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":894 + * ind = np.argmax(r2s) + * b_eq = eqs[ind] + * b_rms = rmss[ind] # <<<<<<<<<<<<<< + * b_r2 = r2s[ind] + * b_overfit = overfit[ind] + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_rmss, __pyx_v_ind); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 894, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_b_rms, __pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":895 + * b_eq = eqs[ind] + * b_rms = rmss[ind] + * b_r2 = r2s[ind] # <<<<<<<<<<<<<< + * b_overfit = overfit[ind] + * + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_r2s, __pyx_v_ind); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 895, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_b_r2, __pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":896 + * b_rms = rmss[ind] + * b_r2 = r2s[ind] + * b_overfit = overfit[ind] # <<<<<<<<<<<<<< + * + * return b_eq, b_rms, b_r2, b_overfit + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_overfit, __pyx_v_ind); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_b_overfit, __pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":890 + * b_overfit = overfit[ind] + * + * if selector == "max_r2s": # <<<<<<<<<<<<<< + * + * ind = np.argmax(r2s) + */ + } + + /* "analysis.py":898 + * b_overfit = overfit[ind] + * + * return b_eq, b_rms, b_r2, b_overfit # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 898, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_b_eq); + __Pyx_GIVEREF(__pyx_v_b_eq); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_b_eq); + __Pyx_INCREF(__pyx_v_b_rms); + __Pyx_GIVEREF(__pyx_v_b_rms); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_b_rms); + __Pyx_INCREF(__pyx_v_b_r2); + __Pyx_GIVEREF(__pyx_v_b_r2); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_b_r2); + __Pyx_INCREF(__pyx_v_b_overfit); + __Pyx_GIVEREF(__pyx_v_b_overfit); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_v_b_overfit); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "analysis.py":872 + * + * + * def select_best_regression(eqs, rmss, r2s, overfit, selector): # <<<<<<<<<<<<<< + * + * b_eq = "" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("analysis.select_best_regression", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_b_eq); + __Pyx_XDECREF(__pyx_v_b_rms); + __Pyx_XDECREF(__pyx_v_b_r2); + __Pyx_XDECREF(__pyx_v_b_overfit); + __Pyx_XDECREF(__pyx_v_ind); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":901 + * + * + * def p_value(x, y): # takes 2 1d arrays # <<<<<<<<<<<<<< + * + * return stats.ttest_ind(x, y)[1] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_35p_value(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_35p_value = {"p_value", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_35p_value, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_35p_value(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_x = 0; + PyObject *__pyx_v_y = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("p_value (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("p_value", 1, 2, 2, 1); __PYX_ERR(0, 901, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "p_value") < 0)) __PYX_ERR(0, 901, __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 = values[0]; + __pyx_v_y = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("p_value", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 901, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.p_value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_34p_value(__pyx_self, __pyx_v_x, __pyx_v_y); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_34p_value(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y) { + 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; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("p_value", 0); + + /* "analysis.py":903 + * def p_value(x, y): # takes 2 1d arrays + * + * return stats.ttest_ind(x, y)[1] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_stats); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 903, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ttest_ind); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 903, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_4 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_x, __pyx_v_y}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 903, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_x, __pyx_v_y}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 903, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 903, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_INCREF(__pyx_v_x); + __Pyx_GIVEREF(__pyx_v_x); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_v_x); + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_y); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 903, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 903, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "analysis.py":901 + * + * + * def p_value(x, y): # takes 2 1d arrays # <<<<<<<<<<<<<< + * + * return stats.ttest_ind(x, y)[1] + */ + + /* 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_5); + __Pyx_AddTraceback("analysis.p_value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":907 + * + * # assumes that rows are the independent variable and columns are the dependant. also assumes that time flows from lowest column to highest column. + * def basic_analysis(data): # <<<<<<<<<<<<<< + * + * row = len(data) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_37basic_analysis(PyObject *__pyx_self, PyObject *__pyx_v_data); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_37basic_analysis = {"basic_analysis", (PyCFunction)__pyx_pw_8analysis_37basic_analysis, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_37basic_analysis(PyObject *__pyx_self, PyObject *__pyx_v_data) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("basic_analysis (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_36basic_analysis(__pyx_self, ((PyObject *)__pyx_v_data)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_36basic_analysis(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data) { + Py_ssize_t __pyx_v_row; + PyObject *__pyx_v_column = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_column_max = NULL; + PyObject *__pyx_v_row_b_stats = NULL; + PyObject *__pyx_v_row_histo = NULL; + PyObject *__pyx_v_column_b_stats = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *(*__pyx_t_4)(PyObject *); + Py_ssize_t __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + __Pyx_RefNannySetupContext("basic_analysis", 0); + + /* "analysis.py":909 + * def basic_analysis(data): + * + * row = len(data) # <<<<<<<<<<<<<< + * column = [] + * + */ + __pyx_t_1 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 909, __pyx_L1_error) + __pyx_v_row = __pyx_t_1; + + /* "analysis.py":910 + * + * row = len(data) + * column = [] # <<<<<<<<<<<<<< + * + * for i in range(0, row, 1): + */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 910, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_column = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":912 + * column = [] + * + * for i in range(0, row, 1): # <<<<<<<<<<<<<< + * column.append(len(data[i])) + * + */ + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_row); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_int_1); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_3 = __pyx_t_2; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 912, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_1 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_2); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(0, 912, __pyx_L1_error) + #else + __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_2); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(0, 912, __pyx_L1_error) + #else + __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_4(__pyx_t_3); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 912, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":913 + * + * for i in range(0, row, 1): + * column.append(len(data[i])) # <<<<<<<<<<<<<< + * + * column_max = max(column) + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_data, __pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 913, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_column, __pyx_t_2); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 913, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":912 + * column = [] + * + * for i in range(0, row, 1): # <<<<<<<<<<<<<< + * column.append(len(data[i])) + * + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "analysis.py":915 + * column.append(len(data[i])) + * + * column_max = max(column) # <<<<<<<<<<<<<< + * row_b_stats = [] + * row_histo = [] + */ + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_max, __pyx_v_column); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 915, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_column_max = __pyx_t_3; + __pyx_t_3 = 0; + + /* "analysis.py":916 + * + * column_max = max(column) + * row_b_stats = [] # <<<<<<<<<<<<<< + * row_histo = [] + * + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 916, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_row_b_stats = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":917 + * column_max = max(column) + * row_b_stats = [] + * row_histo = [] # <<<<<<<<<<<<<< + * + * for i in range(0, row, 1): + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 917, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_row_histo = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":919 + * row_histo = [] + * + * for i in range(0, row, 1): # <<<<<<<<<<<<<< + * row_b_stats.append(basic_stats(data, "row", i)) + * row_histo.append(histo_analysis(data[i], 0.67449, -0.67449, 0.67449)) + */ + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_row); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_int_1); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2); __pyx_t_1 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_1 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 919, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_1 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_1); __Pyx_INCREF(__pyx_t_3); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(0, 919, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_1); __Pyx_INCREF(__pyx_t_3); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(0, 919, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_4(__pyx_t_2); + 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(0, 919, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":920 + * + * for i in range(0, row, 1): + * row_b_stats.append(basic_stats(data, "row", i)) # <<<<<<<<<<<<<< + * row_histo.append(histo_analysis(data[i], 0.67449, -0.67449, 0.67449)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_basic_stats); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_9 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_v_data, __pyx_n_s_row, __pyx_v_i}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 920, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_v_data, __pyx_n_s_row, __pyx_v_i}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 920, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_INCREF(__pyx_v_data); + __Pyx_GIVEREF(__pyx_v_data); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_v_data); + __Pyx_INCREF(__pyx_n_s_row); + __Pyx_GIVEREF(__pyx_n_s_row); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_n_s_row); + __Pyx_INCREF(__pyx_v_i); + __Pyx_GIVEREF(__pyx_v_i); + PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_v_i); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_row_b_stats, __pyx_t_3); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 920, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "analysis.py":921 + * for i in range(0, row, 1): + * row_b_stats.append(basic_stats(data, "row", i)) + * row_histo.append(histo_analysis(data[i], 0.67449, -0.67449, 0.67449)) # <<<<<<<<<<<<<< + * + * column_b_stats = [] + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_histo_analysis); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = __Pyx_PyObject_GetItem(__pyx_v_data, __pyx_v_i); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_9 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_t_10, __pyx_float_0_67449, __pyx_float_neg_0_67449, __pyx_float_0_67449}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 4+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 921, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_t_10, __pyx_float_0_67449, __pyx_float_neg_0_67449, __pyx_float_0_67449}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 4+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 921, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + { + __pyx_t_11 = PyTuple_New(4+__pyx_t_9); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_9, __pyx_t_10); + __Pyx_INCREF(__pyx_float_0_67449); + __Pyx_GIVEREF(__pyx_float_0_67449); + PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_9, __pyx_float_0_67449); + __Pyx_INCREF(__pyx_float_neg_0_67449); + __Pyx_GIVEREF(__pyx_float_neg_0_67449); + PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_9, __pyx_float_neg_0_67449); + __Pyx_INCREF(__pyx_float_0_67449); + __Pyx_GIVEREF(__pyx_float_0_67449); + PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_9, __pyx_float_0_67449); + __pyx_t_10 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_row_histo, __pyx_t_3); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 921, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "analysis.py":919 + * row_histo = [] + * + * for i in range(0, row, 1): # <<<<<<<<<<<<<< + * row_b_stats.append(basic_stats(data, "row", i)) + * row_histo.append(histo_analysis(data[i], 0.67449, -0.67449, 0.67449)) + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":923 + * row_histo.append(histo_analysis(data[i], 0.67449, -0.67449, 0.67449)) + * + * column_b_stats = [] # <<<<<<<<<<<<<< + * + * for i in range(0, column_max, 1): + */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 923, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_column_b_stats = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":925 + * column_b_stats = [] + * + * for i in range(0, column_max, 1): # <<<<<<<<<<<<<< + * column_b_stats.append(basic_stats(data, "column", i)) + * + */ + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_0); + __Pyx_INCREF(__pyx_v_column_max); + __Pyx_GIVEREF(__pyx_v_column_max); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_column_max); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_int_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2); __pyx_t_1 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_1 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 925, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_1 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_1); __Pyx_INCREF(__pyx_t_3); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(0, 925, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_1); __Pyx_INCREF(__pyx_t_3); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(0, 925, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_4(__pyx_t_2); + 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(0, 925, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":926 + * + * for i in range(0, column_max, 1): + * column_b_stats.append(basic_stats(data, "column", i)) # <<<<<<<<<<<<<< + * + * return[row_b_stats, column_b_stats, row_histo] + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_basic_stats); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_11 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_9 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[4] = {__pyx_t_11, __pyx_v_data, __pyx_n_s_column, __pyx_v_i}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 926, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[4] = {__pyx_t_11, __pyx_v_data, __pyx_n_s_column, __pyx_v_i}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 926, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_11) { + __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_11); __pyx_t_11 = NULL; + } + __Pyx_INCREF(__pyx_v_data); + __Pyx_GIVEREF(__pyx_v_data); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_v_data); + __Pyx_INCREF(__pyx_n_s_column); + __Pyx_GIVEREF(__pyx_n_s_column); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_n_s_column); + __Pyx_INCREF(__pyx_v_i); + __Pyx_GIVEREF(__pyx_v_i); + PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_v_i); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_column_b_stats, __pyx_t_3); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 926, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "analysis.py":925 + * column_b_stats = [] + * + * for i in range(0, column_max, 1): # <<<<<<<<<<<<<< + * column_b_stats.append(basic_stats(data, "column", i)) + * + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":928 + * column_b_stats.append(basic_stats(data, "column", i)) + * + * return[row_b_stats, column_b_stats, row_histo] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyList_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 928, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_row_b_stats); + __Pyx_GIVEREF(__pyx_v_row_b_stats); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v_row_b_stats); + __Pyx_INCREF(__pyx_v_column_b_stats); + __Pyx_GIVEREF(__pyx_v_column_b_stats); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_v_column_b_stats); + __Pyx_INCREF(__pyx_v_row_histo); + __Pyx_GIVEREF(__pyx_v_row_histo); + PyList_SET_ITEM(__pyx_t_2, 2, __pyx_v_row_histo); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "analysis.py":907 + * + * # assumes that rows are the independent variable and columns are the dependant. also assumes that time flows from lowest column to highest column. + * def basic_analysis(data): # <<<<<<<<<<<<<< + * + * row = len(data) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("analysis.basic_analysis", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_column); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_column_max); + __Pyx_XDECREF(__pyx_v_row_b_stats); + __Pyx_XDECREF(__pyx_v_row_histo); + __Pyx_XDECREF(__pyx_v_column_b_stats); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":931 + * + * + * def benchmark(x, y): # <<<<<<<<<<<<<< + * + * start_g = time.time() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_39benchmark(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_39benchmark = {"benchmark", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_39benchmark, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_39benchmark(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_x = 0; + PyObject *__pyx_v_y = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benchmark (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("benchmark", 1, 2, 2, 1); __PYX_ERR(0, 931, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "benchmark") < 0)) __PYX_ERR(0, 931, __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 = values[0]; + __pyx_v_y = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("benchmark", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 931, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.benchmark", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_38benchmark(__pyx_self, __pyx_v_x, __pyx_v_y); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_38benchmark(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y) { + PyObject *__pyx_v_start_g = NULL; + PyObject *__pyx_v_end_g = NULL; + PyObject *__pyx_v_start_a = NULL; + PyObject *__pyx_v_end_a = NULL; + 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; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("benchmark", 0); + + /* "analysis.py":933 + * def benchmark(x, y): + * + * start_g = time.time() # <<<<<<<<<<<<<< + * generate_data("data/data.csv", x, y, -10, 10) + * end_g = time.time() + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_start_g = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":934 + * + * start_g = time.time() + * generate_data("data/data.csv", x, y, -10, 10) # <<<<<<<<<<<<<< + * end_g = time.time() + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_generate_data); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 934, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + __pyx_t_4 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[6] = {__pyx_t_2, __pyx_kp_s_data_data_csv, __pyx_v_x, __pyx_v_y, __pyx_int_neg_10, __pyx_int_10}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 5+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 934, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[6] = {__pyx_t_2, __pyx_kp_s_data_data_csv, __pyx_v_x, __pyx_v_y, __pyx_int_neg_10, __pyx_int_10}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 5+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 934, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_5 = PyTuple_New(5+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 934, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_INCREF(__pyx_kp_s_data_data_csv); + __Pyx_GIVEREF(__pyx_kp_s_data_data_csv); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_kp_s_data_data_csv); + __Pyx_INCREF(__pyx_v_x); + __Pyx_GIVEREF(__pyx_v_x); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_x); + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_5, 2+__pyx_t_4, __pyx_v_y); + __Pyx_INCREF(__pyx_int_neg_10); + __Pyx_GIVEREF(__pyx_int_neg_10); + PyTuple_SET_ITEM(__pyx_t_5, 3+__pyx_t_4, __pyx_int_neg_10); + __Pyx_INCREF(__pyx_int_10); + __Pyx_GIVEREF(__pyx_int_10); + PyTuple_SET_ITEM(__pyx_t_5, 4+__pyx_t_4, __pyx_int_10); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 934, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":935 + * start_g = time.time() + * generate_data("data/data.csv", x, y, -10, 10) + * end_g = time.time() # <<<<<<<<<<<<<< + * + * start_a = time.time() + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 935, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 935, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 935, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_end_g = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":937 + * end_g = time.time() + * + * start_a = time.time() # <<<<<<<<<<<<<< + * basic_analysis("data/data.csv") + * end_a = time.time() + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 937, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 937, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 937, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_start_a = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":938 + * + * start_a = time.time() + * basic_analysis("data/data.csv") # <<<<<<<<<<<<<< + * end_a = time.time() + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_basic_analysis); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_kp_s_data_data_csv) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_s_data_data_csv); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":939 + * start_a = time.time() + * basic_analysis("data/data.csv") + * end_a = time.time() # <<<<<<<<<<<<<< + * + * return [(end_g - start_g), (end_a - start_a)] + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_time); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_end_a = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":941 + * end_a = time.time() + * + * return [(end_g - start_g), (end_a - start_a)] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyNumber_Subtract(__pyx_v_end_g, __pyx_v_start_g); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PyNumber_Subtract(__pyx_v_end_a, __pyx_v_start_a); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyList_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_5); + PyList_SET_ITEM(__pyx_t_3, 1, __pyx_t_5); + __pyx_t_1 = 0; + __pyx_t_5 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "analysis.py":931 + * + * + * def benchmark(x, y): # <<<<<<<<<<<<<< + * + * start_g = time.time() + */ + + /* 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_5); + __Pyx_AddTraceback("analysis.benchmark", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_start_g); + __Pyx_XDECREF(__pyx_v_end_g); + __Pyx_XDECREF(__pyx_v_start_a); + __Pyx_XDECREF(__pyx_v_end_a); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":944 + * + * + * def generate_data(filename, x, y, low, high): # <<<<<<<<<<<<<< + * + * file = open(filename, "w") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_41generate_data(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_41generate_data = {"generate_data", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_41generate_data, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_41generate_data(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_filename = 0; + PyObject *__pyx_v_x = 0; + PyObject *__pyx_v_y = 0; + PyObject *__pyx_v_low = 0; + PyObject *__pyx_v_high = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("generate_data (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_low,&__pyx_n_s_high,0}; + PyObject* values[5] = {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 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_filename)) != 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("generate_data", 1, 5, 5, 1); __PYX_ERR(0, 944, __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("generate_data", 1, 5, 5, 2); __PYX_ERR(0, 944, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("generate_data", 1, 5, 5, 3); __PYX_ERR(0, 944, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("generate_data", 1, 5, 5, 4); __PYX_ERR(0, 944, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "generate_data") < 0)) __PYX_ERR(0, 944, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { + 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); + } + __pyx_v_filename = values[0]; + __pyx_v_x = values[1]; + __pyx_v_y = values[2]; + __pyx_v_low = values[3]; + __pyx_v_high = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("generate_data", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 944, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.generate_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_40generate_data(__pyx_self, __pyx_v_filename, __pyx_v_x, __pyx_v_y, __pyx_v_low, __pyx_v_high); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_40generate_data(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_x, PyObject *__pyx_v_y, PyObject *__pyx_v_low, PyObject *__pyx_v_high) { + PyObject *__pyx_v_file = NULL; + CYTHON_UNUSED PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_temp = NULL; + CYTHON_UNUSED PyObject *__pyx_v_j = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + Py_ssize_t __pyx_t_6; + PyObject *(*__pyx_t_7)(PyObject *); + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + __Pyx_RefNannySetupContext("generate_data", 0); + + /* "analysis.py":946 + * def generate_data(filename, x, y, low, high): + * + * file = open(filename, "w") # <<<<<<<<<<<<<< + * + * for i in range(0, y, 1): + */ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 946, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_filename); + __Pyx_INCREF(__pyx_n_s_w); + __Pyx_GIVEREF(__pyx_n_s_w); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_w); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_open, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 946, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_file = __pyx_t_2; + __pyx_t_2 = 0; + + /* "analysis.py":948 + * file = open(filename, "w") + * + * for i in range(0, y, 1): # <<<<<<<<<<<<<< + * temp = "" + * + */ + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 948, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_0); + __Pyx_INCREF(__pyx_v_y); + __Pyx_GIVEREF(__pyx_v_y); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_y); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_int_1); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 948, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 948, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 948, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 948, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 948, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 948, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 948, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 948, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":949 + * + * for i in range(0, y, 1): + * temp = "" # <<<<<<<<<<<<<< + * + * for j in range(0, x - 1, 1): + */ + __Pyx_INCREF(__pyx_kp_s__2); + __Pyx_XDECREF_SET(__pyx_v_temp, __pyx_kp_s__2); + + /* "analysis.py":951 + * temp = "" + * + * for j in range(0, x - 1, 1): # <<<<<<<<<<<<<< + * temp = str(random.uniform(low, high)) + "," + temp + * + */ + __pyx_t_1 = __Pyx_PyInt_SubtractObjC(__pyx_v_x, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_int_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + } else { + __pyx_t_6 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 951, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_7)) { + if (likely(PyList_CheckExact(__pyx_t_5))) { + if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_5)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 951, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_5, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_5)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 951, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_5, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_7(__pyx_t_5); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 951, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_j, __pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":952 + * + * for j in range(0, x - 1, 1): + * temp = str(random.uniform(low, high)) + "," + temp # <<<<<<<<<<<<<< + * + * temp = temp + str(random.uniform(low, high)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_random); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 952, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_uniform); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 952, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_low, __pyx_v_high}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 952, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_low, __pyx_v_high}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 952, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 952, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_INCREF(__pyx_v_low); + __Pyx_GIVEREF(__pyx_v_low); + PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_v_low); + __Pyx_INCREF(__pyx_v_high); + __Pyx_GIVEREF(__pyx_v_high); + PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_v_high); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 952, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 952, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_9, __pyx_kp_s__14); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 952, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PyNumber_Add(__pyx_t_1, __pyx_v_temp); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 952, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_temp, __pyx_t_9); + __pyx_t_9 = 0; + + /* "analysis.py":951 + * temp = "" + * + * for j in range(0, x - 1, 1): # <<<<<<<<<<<<<< + * temp = str(random.uniform(low, high)) + "," + temp + * + */ + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "analysis.py":954 + * temp = str(random.uniform(low, high)) + "," + temp + * + * temp = temp + str(random.uniform(low, high)) # <<<<<<<<<<<<<< + * file.write(temp + "\n") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_random); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_uniform); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_v_low, __pyx_v_high}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_v_low, __pyx_v_high}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else + #endif + { + __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + if (__pyx_t_9) { + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL; + } + __Pyx_INCREF(__pyx_v_low); + __Pyx_GIVEREF(__pyx_v_low); + PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_v_low); + __Pyx_INCREF(__pyx_v_high); + __Pyx_GIVEREF(__pyx_v_high); + PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_v_high); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_11, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Add(__pyx_v_temp, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_temp, __pyx_t_5); + __pyx_t_5 = 0; + + /* "analysis.py":955 + * + * temp = temp + str(random.uniform(low, high)) + * file.write(temp + "\n") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_file, __pyx_n_s_write); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 955, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_11 = PyNumber_Add(__pyx_v_temp, __pyx_kp_s__15); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 955, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_5 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_9, __pyx_t_11) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_11); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 955, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "analysis.py":948 + * file = open(filename, "w") + * + * for i in range(0, y, 1): # <<<<<<<<<<<<<< + * temp = "" + * + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":944 + * + * + * def generate_data(filename, x, y, low, high): # <<<<<<<<<<<<<< + * + * file = open(filename, "w") + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("analysis.generate_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_file); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_temp); + __Pyx_XDECREF(__pyx_v_j); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":962 + * + * + * def _sum(data, start=0): # <<<<<<<<<<<<<< + * count = 0 + * n, d = _exact_ratio(start) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_43_sum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_43_sum = {"_sum", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_43_sum, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_43_sum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_data = 0; + PyObject *__pyx_v_start = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_sum (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_data,&__pyx_n_s_start,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)((PyObject *)__pyx_int_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_data)) != 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_start); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_sum") < 0)) __PYX_ERR(0, 962, __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_data = values[0]; + __pyx_v_start = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_sum", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 962, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis._sum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_42_sum(__pyx_self, __pyx_v_data, __pyx_v_start); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_8analysis_4_sum_2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "analysis.py":979 + * else: + * + * total = sum(Fraction(n, d) for d, n in sorted(partials.items())) # <<<<<<<<<<<<<< + * return (T, total, count) + * + */ + +static PyObject *__pyx_pf_8analysis_4_sum_genexpr(PyObject *__pyx_self) { + struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr *)__pyx_tp_new_8analysis___pyx_scope_struct_1_genexpr(__pyx_ptype_8analysis___pyx_scope_struct_1_genexpr, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 979, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_8analysis___pyx_scope_struct___sum *) __pyx_self; + __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_8analysis_4_sum_2generator1, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_sum_locals_genexpr, __pyx_n_s_analysis); if (unlikely(!gen)) __PYX_ERR(0, 979, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("analysis._sum.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_8analysis_4_sum_2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr *__pyx_cur_scope = ((struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *(*__pyx_t_8)(PyObject *); + int __pyx_t_9; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L8_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 979, __pyx_L1_error) + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_partials)) { __Pyx_RaiseClosureNameError("partials"); __PYX_ERR(0, 979, __pyx_L1_error) } + if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_partials == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(0, 979, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyDict_Items(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_partials); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 979, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PySequence_List(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 979, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_4 = PyList_Sort(__pyx_t_1); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 979, __pyx_L1_error) + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 979, __pyx_L1_error) + } + __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 979, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 979, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + 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(0, 979, __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_6 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_6 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 979, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 979, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 979, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; + index = 0; __pyx_t_2 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_2)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 979, __pyx_L1_error) + __pyx_t_8 = NULL; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L7_unpacking_done; + __pyx_L6_unpacking_failed:; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 979, __pyx_L1_error) + __pyx_L7_unpacking_done:; + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_d); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_d, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_n); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_n, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_Fraction); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 979, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_9 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_cur_scope->__pyx_v_n, __pyx_cur_scope->__pyx_v_d}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 979, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_cur_scope->__pyx_v_n, __pyx_cur_scope->__pyx_v_d}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 979, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_7 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 979, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_n); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_n); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_9, __pyx_cur_scope->__pyx_v_n); + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_d); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_d); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_9, __pyx_cur_scope->__pyx_v_d); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 979, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + __Pyx_XGIVEREF(__pyx_t_3); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_3; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_5; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L8_resume_from_yield:; + __pyx_t_3 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_3); + __pyx_t_5 = __pyx_cur_scope->__pyx_t_1; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 979, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + PyErr_SetNone(PyExc_StopIteration); + 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_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":962 + * + * + * def _sum(data, start=0): # <<<<<<<<<<<<<< + * count = 0 + * n, d = _exact_ratio(start) + */ + +static PyObject *__pyx_pf_8analysis_42_sum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data, PyObject *__pyx_v_start) { + struct __pyx_obj_8analysis___pyx_scope_struct___sum *__pyx_cur_scope; + PyObject *__pyx_v_count = NULL; + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_d = NULL; + PyObject *__pyx_v_partials_get = NULL; + PyObject *__pyx_v_T = NULL; + PyObject *__pyx_v_typ = NULL; + PyObject *__pyx_v_values = NULL; + PyObject *__pyx_v_total = 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)(PyObject *); + int __pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + PyObject *__pyx_t_9 = NULL; + Py_ssize_t __pyx_t_10; + PyObject *(*__pyx_t_11)(PyObject *); + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + __Pyx_RefNannySetupContext("_sum", 0); + __pyx_cur_scope = (struct __pyx_obj_8analysis___pyx_scope_struct___sum *)__pyx_tp_new_8analysis___pyx_scope_struct___sum(__pyx_ptype_8analysis___pyx_scope_struct___sum, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_8analysis___pyx_scope_struct___sum *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 962, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + + /* "analysis.py":963 + * + * def _sum(data, start=0): + * count = 0 # <<<<<<<<<<<<<< + * n, d = _exact_ratio(start) + * partials = {d: n} + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_v_count = __pyx_int_0; + + /* "analysis.py":964 + * def _sum(data, start=0): + * count = 0 + * n, d = _exact_ratio(start) # <<<<<<<<<<<<<< + * partials = {d: n} + * partials_get = partials.get + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_exact_ratio); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __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_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_start) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_start); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 964, __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(0, 964, __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(0, 964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 964, __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(0, 964, __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(0, 964, __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(0, 964, __pyx_L1_error) + __pyx_L4_unpacking_done:; + } + __pyx_v_n = __pyx_t_2; + __pyx_t_2 = 0; + __pyx_v_d = __pyx_t_3; + __pyx_t_3 = 0; + + /* "analysis.py":965 + * count = 0 + * n, d = _exact_ratio(start) + * partials = {d: n} # <<<<<<<<<<<<<< + * partials_get = partials.get + * T = _coerce(int, type(start)) + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 965, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_v_d, __pyx_v_n) < 0) __PYX_ERR(0, 965, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_v_partials = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":966 + * n, d = _exact_ratio(start) + * partials = {d: n} + * partials_get = partials.get # <<<<<<<<<<<<<< + * T = _coerce(int, type(start)) + * for typ, values in groupby(data, type): + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_partials, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 966, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_partials_get = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":967 + * partials = {d: n} + * partials_get = partials.get + * T = _coerce(int, type(start)) # <<<<<<<<<<<<<< + * for typ, values in groupby(data, type): + * T = _coerce(T, typ) # or raise TypeError + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_coerce); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 967, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, ((PyObject *)(&PyInt_Type)), ((PyObject *)Py_TYPE(__pyx_v_start))}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 967, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, ((PyObject *)(&PyInt_Type)), ((PyObject *)Py_TYPE(__pyx_v_start))}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 967, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 967, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_INCREF(((PyObject *)(&PyInt_Type))); + __Pyx_GIVEREF(((PyObject *)(&PyInt_Type))); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, ((PyObject *)(&PyInt_Type))); + __Pyx_INCREF(((PyObject *)Py_TYPE(__pyx_v_start))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(__pyx_v_start))); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, ((PyObject *)Py_TYPE(__pyx_v_start))); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 967, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_T = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":968 + * partials_get = partials.get + * T = _coerce(int, type(start)) + * for typ, values in groupby(data, type): # <<<<<<<<<<<<<< + * T = _coerce(T, typ) # or raise TypeError + * for n, d in map(_exact_ratio, values): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_groupby); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + 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_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_data, ((PyObject *)(&PyType_Type))}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 968, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_data, ((PyObject *)(&PyType_Type))}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 968, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_2 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(__pyx_v_data); + __Pyx_GIVEREF(__pyx_v_data); + PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_6, __pyx_v_data); + __Pyx_INCREF(((PyObject *)(&PyType_Type))); + __Pyx_GIVEREF(((PyObject *)(&PyType_Type))); + PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_6, ((PyObject *)(&PyType_Type))); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 968, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_8)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_1); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 968, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_1); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 968, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_8(__pyx_t_3); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 968, __pyx_L1_error) + } + break; + } + __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 != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 968, __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_4 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_4 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 968, __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_9 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = Py_TYPE(__pyx_t_9)->tp_iternext; + index = 0; __pyx_t_2 = __pyx_t_5(__pyx_t_9); if (unlikely(!__pyx_t_2)) goto __pyx_L7_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_4 = __pyx_t_5(__pyx_t_9); if (unlikely(!__pyx_t_4)) goto __pyx_L7_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_9), 2) < 0) __PYX_ERR(0, 968, __pyx_L1_error) + __pyx_t_5 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L8_unpacking_done; + __pyx_L7_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_5 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 968, __pyx_L1_error) + __pyx_L8_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_typ, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_values, __pyx_t_4); + __pyx_t_4 = 0; + + /* "analysis.py":969 + * T = _coerce(int, type(start)) + * for typ, values in groupby(data, type): + * T = _coerce(T, typ) # or raise TypeError # <<<<<<<<<<<<<< + * for n, d in map(_exact_ratio, values): + * count += 1 + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_coerce); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 969, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(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_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_T, __pyx_v_typ}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 969, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_T, __pyx_v_typ}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 969, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 969, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_INCREF(__pyx_v_T); + __Pyx_GIVEREF(__pyx_v_T); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_6, __pyx_v_T); + __Pyx_INCREF(__pyx_v_typ); + __Pyx_GIVEREF(__pyx_v_typ); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_typ); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 969, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_T, __pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":970 + * for typ, values in groupby(data, type): + * T = _coerce(T, typ) # or raise TypeError + * for n, d in map(_exact_ratio, values): # <<<<<<<<<<<<<< + * count += 1 + * partials[d] = partials_get(d, 0) + n + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_exact_ratio); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 970, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 970, __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(__pyx_v_values); + __Pyx_GIVEREF(__pyx_v_values); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_values); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_map, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 970, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_4 = __pyx_t_1; __Pyx_INCREF(__pyx_t_4); __pyx_t_10 = 0; + __pyx_t_11 = NULL; + } else { + __pyx_t_10 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 970, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 970, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_11)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + if (__pyx_t_10 >= PyList_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_10); __Pyx_INCREF(__pyx_t_1); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 970, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 970, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + if (__pyx_t_10 >= PyTuple_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_10); __Pyx_INCREF(__pyx_t_1); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 970, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 970, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_11(__pyx_t_4); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 970, __pyx_L1_error) + } + break; + } + __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 != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 970, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_9 = PyList_GET_ITEM(sequence, 0); + __pyx_t_2 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(__pyx_t_2); + #else + __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 970, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 970, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_12 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 970, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = Py_TYPE(__pyx_t_12)->tp_iternext; + index = 0; __pyx_t_9 = __pyx_t_5(__pyx_t_12); if (unlikely(!__pyx_t_9)) goto __pyx_L11_unpacking_failed; + __Pyx_GOTREF(__pyx_t_9); + index = 1; __pyx_t_2 = __pyx_t_5(__pyx_t_12); if (unlikely(!__pyx_t_2)) goto __pyx_L11_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_12), 2) < 0) __PYX_ERR(0, 970, __pyx_L1_error) + __pyx_t_5 = NULL; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + goto __pyx_L12_unpacking_done; + __pyx_L11_unpacking_failed:; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_5 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 970, __pyx_L1_error) + __pyx_L12_unpacking_done:; + } + __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_9); + __pyx_t_9 = 0; + __Pyx_DECREF_SET(__pyx_v_d, __pyx_t_2); + __pyx_t_2 = 0; + + /* "analysis.py":971 + * T = _coerce(T, typ) # or raise TypeError + * for n, d in map(_exact_ratio, values): + * count += 1 # <<<<<<<<<<<<<< + * partials[d] = partials_get(d, 0) + n + * if None in partials: + */ + __pyx_t_1 = __Pyx_PyInt_AddObjC(__pyx_v_count, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 971, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_count, __pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":972 + * for n, d in map(_exact_ratio, values): + * count += 1 + * partials[d] = partials_get(d, 0) + n # <<<<<<<<<<<<<< + * if None in partials: + * + */ + __pyx_t_1 = __Pyx_PyDict_GetItemDefault(__pyx_cur_scope->__pyx_v_partials, __pyx_v_d, __pyx_int_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 972, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_v_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 972, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(PyDict_SetItem(__pyx_cur_scope->__pyx_v_partials, __pyx_v_d, __pyx_t_2) < 0)) __PYX_ERR(0, 972, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":970 + * for typ, values in groupby(data, type): + * T = _coerce(T, typ) # or raise TypeError + * for n, d in map(_exact_ratio, values): # <<<<<<<<<<<<<< + * count += 1 + * partials[d] = partials_get(d, 0) + n + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "analysis.py":968 + * partials_get = partials.get + * T = _coerce(int, type(start)) + * for typ, values in groupby(data, type): # <<<<<<<<<<<<<< + * T = _coerce(T, typ) # or raise TypeError + * for n, d in map(_exact_ratio, values): + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "analysis.py":973 + * count += 1 + * partials[d] = partials_get(d, 0) + n + * if None in partials: # <<<<<<<<<<<<<< + * + * total = partials[None] + */ + __pyx_t_13 = (__Pyx_PyDict_ContainsTF(Py_None, __pyx_cur_scope->__pyx_v_partials, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 973, __pyx_L1_error) + __pyx_t_14 = (__pyx_t_13 != 0); + if (__pyx_t_14) { + + /* "analysis.py":975 + * if None in partials: + * + * total = partials[None] # <<<<<<<<<<<<<< + * assert not _isfinite(total) + * else: + */ + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_partials, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 975, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_total = __pyx_t_3; + __pyx_t_3 = 0; + + /* "analysis.py":976 + * + * total = partials[None] + * assert not _isfinite(total) # <<<<<<<<<<<<<< + * else: + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_isfinite); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 976, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(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_v_total) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_total); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 976, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 976, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!((!__pyx_t_14) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(0, 976, __pyx_L1_error) + } + } + #endif + + /* "analysis.py":973 + * count += 1 + * partials[d] = partials_get(d, 0) + n + * if None in partials: # <<<<<<<<<<<<<< + * + * total = partials[None] + */ + goto __pyx_L13; + } + + /* "analysis.py":979 + * else: + * + * total = sum(Fraction(n, d) for d, n in sorted(partials.items())) # <<<<<<<<<<<<<< + * return (T, total, count) + * + */ + /*else*/ { + __pyx_t_3 = __pyx_pf_8analysis_4_sum_genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 979, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_sum, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 979, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_total = __pyx_t_4; + __pyx_t_4 = 0; + } + __pyx_L13:; + + /* "analysis.py":980 + * + * total = sum(Fraction(n, d) for d, n in sorted(partials.items())) + * return (T, total, count) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 980, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_T); + __Pyx_GIVEREF(__pyx_v_T); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_T); + __Pyx_INCREF(__pyx_v_total); + __Pyx_GIVEREF(__pyx_v_total); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_total); + __Pyx_INCREF(__pyx_v_count); + __Pyx_GIVEREF(__pyx_v_count); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_count); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "analysis.py":962 + * + * + * def _sum(data, start=0): # <<<<<<<<<<<<<< + * count = 0 + * n, d = _exact_ratio(start) + */ + + /* 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_9); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_AddTraceback("analysis._sum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_count); + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_d); + __Pyx_XDECREF(__pyx_v_partials_get); + __Pyx_XDECREF(__pyx_v_T); + __Pyx_XDECREF(__pyx_v_typ); + __Pyx_XDECREF(__pyx_v_values); + __Pyx_XDECREF(__pyx_v_total); + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":983 + * + * + * def _isfinite(x): # <<<<<<<<<<<<<< + * try: + * return x.is_finite() # Likely a Decimal. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_45_isfinite(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_45_isfinite = {"_isfinite", (PyCFunction)__pyx_pw_8analysis_45_isfinite, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_45_isfinite(PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_isfinite (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_44_isfinite(__pyx_self, ((PyObject *)__pyx_v_x)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_44_isfinite(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { + 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; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + __Pyx_RefNannySetupContext("_isfinite", 0); + + /* "analysis.py":984 + * + * def _isfinite(x): + * try: # <<<<<<<<<<<<<< + * return x.is_finite() # Likely a Decimal. + * except AttributeError: + */ + { + __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:*/ { + + /* "analysis.py":985 + * def _isfinite(x): + * try: + * return x.is_finite() # Likely a Decimal. # <<<<<<<<<<<<<< + * except AttributeError: + * return math.isfinite(x) # Coerces to float first. + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_is_finite); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 985, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 985, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L7_try_return; + + /* "analysis.py":984 + * + * def _isfinite(x): + * try: # <<<<<<<<<<<<<< + * return x.is_finite() # Likely a Decimal. + * except AttributeError: + */ + } + __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; + + /* "analysis.py":986 + * try: + * return x.is_finite() # Likely a Decimal. + * except AttributeError: # <<<<<<<<<<<<<< + * return math.isfinite(x) # Coerces to float first. + * + */ + __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError); + if (__pyx_t_7) { + __Pyx_AddTraceback("analysis._isfinite", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(0, 986, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + + /* "analysis.py":987 + * return x.is_finite() # Likely a Decimal. + * except AttributeError: + * return math.isfinite(x) # Coerces to float first. # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_math); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 987, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_isfinite_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 987, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + } + } + __pyx_t_8 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_9, __pyx_v_x) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_x); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 987, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_r = __pyx_t_8; + __pyx_t_8 = 0; + __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; + goto __pyx_L6_except_return; + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "analysis.py":984 + * + * def _isfinite(x): + * try: # <<<<<<<<<<<<<< + * return x.is_finite() # Likely a Decimal. + * except AttributeError: + */ + __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_L7_try_return:; + __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_L0; + __pyx_L6_except_return:; + __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_L0; + } + + /* "analysis.py":983 + * + * + * def _isfinite(x): # <<<<<<<<<<<<<< + * try: + * return x.is_finite() # Likely a Decimal. + */ + + /* 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_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("analysis._isfinite", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":990 + * + * + * def _coerce(T, S): # <<<<<<<<<<<<<< + * + * assert T is not bool, "initial type T is bool" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_47_coerce(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_47_coerce = {"_coerce", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_47_coerce, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_47_coerce(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_T = 0; + PyObject *__pyx_v_S = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_coerce (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_T,&__pyx_n_s_S,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_T)) != 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("_coerce", 1, 2, 2, 1); __PYX_ERR(0, 990, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_coerce") < 0)) __PYX_ERR(0, 990, __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_T = values[0]; + __pyx_v_S = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_coerce", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 990, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis._coerce", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_46_coerce(__pyx_self, __pyx_v_T, __pyx_v_S); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_46_coerce(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_T, PyObject *__pyx_v_S) { + PyObject *__pyx_v_msg = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("_coerce", 0); + + /* "analysis.py":992 + * def _coerce(T, S): + * + * assert T is not bool, "initial type T is bool" # <<<<<<<<<<<<<< + * + * if T is S: + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + __pyx_t_1 = (__pyx_v_T != ((PyObject*)&PyBool_Type)); + if (unlikely(!(__pyx_t_1 != 0))) { + PyErr_SetObject(PyExc_AssertionError, __pyx_kp_s_initial_type_T_is_bool); + __PYX_ERR(0, 992, __pyx_L1_error) + } + } + #endif + + /* "analysis.py":994 + * assert T is not bool, "initial type T is bool" + * + * if T is S: # <<<<<<<<<<<<<< + * return T + * + */ + __pyx_t_1 = (__pyx_v_T == __pyx_v_S); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "analysis.py":995 + * + * if T is S: + * return T # <<<<<<<<<<<<<< + * + * if S is int or S is bool: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_T); + __pyx_r = __pyx_v_T; + goto __pyx_L0; + + /* "analysis.py":994 + * assert T is not bool, "initial type T is bool" + * + * if T is S: # <<<<<<<<<<<<<< + * return T + * + */ + } + + /* "analysis.py":997 + * return T + * + * if S is int or S is bool: # <<<<<<<<<<<<<< + * return T + * if T is int: + */ + __pyx_t_1 = (__pyx_v_S == ((PyObject *)(&PyInt_Type))); + __pyx_t_3 = (__pyx_t_1 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_3 = (__pyx_v_S == ((PyObject*)&PyBool_Type)); + __pyx_t_1 = (__pyx_t_3 != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L5_bool_binop_done:; + if (__pyx_t_2) { + + /* "analysis.py":998 + * + * if S is int or S is bool: + * return T # <<<<<<<<<<<<<< + * if T is int: + * return S + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_T); + __pyx_r = __pyx_v_T; + goto __pyx_L0; + + /* "analysis.py":997 + * return T + * + * if S is int or S is bool: # <<<<<<<<<<<<<< + * return T + * if T is int: + */ + } + + /* "analysis.py":999 + * if S is int or S is bool: + * return T + * if T is int: # <<<<<<<<<<<<<< + * return S + * + */ + __pyx_t_2 = (__pyx_v_T == ((PyObject *)(&PyInt_Type))); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "analysis.py":1000 + * return T + * if T is int: + * return S # <<<<<<<<<<<<<< + * + * if issubclass(S, T): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_S); + __pyx_r = __pyx_v_S; + goto __pyx_L0; + + /* "analysis.py":999 + * if S is int or S is bool: + * return T + * if T is int: # <<<<<<<<<<<<<< + * return S + * + */ + } + + /* "analysis.py":1002 + * return S + * + * if issubclass(S, T): # <<<<<<<<<<<<<< + * return S + * if issubclass(T, S): + */ + __pyx_t_1 = PyObject_IsSubclass(__pyx_v_S, __pyx_v_T); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 1002, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "analysis.py":1003 + * + * if issubclass(S, T): + * return S # <<<<<<<<<<<<<< + * if issubclass(T, S): + * return T + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_S); + __pyx_r = __pyx_v_S; + goto __pyx_L0; + + /* "analysis.py":1002 + * return S + * + * if issubclass(S, T): # <<<<<<<<<<<<<< + * return S + * if issubclass(T, S): + */ + } + + /* "analysis.py":1004 + * if issubclass(S, T): + * return S + * if issubclass(T, S): # <<<<<<<<<<<<<< + * return T + * + */ + __pyx_t_2 = PyObject_IsSubclass(__pyx_v_T, __pyx_v_S); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 1004, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "analysis.py":1005 + * return S + * if issubclass(T, S): + * return T # <<<<<<<<<<<<<< + * + * if issubclass(T, int): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_T); + __pyx_r = __pyx_v_T; + goto __pyx_L0; + + /* "analysis.py":1004 + * if issubclass(S, T): + * return S + * if issubclass(T, S): # <<<<<<<<<<<<<< + * return T + * + */ + } + + /* "analysis.py":1007 + * return T + * + * if issubclass(T, int): # <<<<<<<<<<<<<< + * return S + * if issubclass(S, int): + */ + __pyx_t_1 = PyObject_IsSubclass(__pyx_v_T, ((PyObject *)(&PyInt_Type))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 1007, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "analysis.py":1008 + * + * if issubclass(T, int): + * return S # <<<<<<<<<<<<<< + * if issubclass(S, int): + * return T + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_S); + __pyx_r = __pyx_v_S; + goto __pyx_L0; + + /* "analysis.py":1007 + * return T + * + * if issubclass(T, int): # <<<<<<<<<<<<<< + * return S + * if issubclass(S, int): + */ + } + + /* "analysis.py":1009 + * if issubclass(T, int): + * return S + * if issubclass(S, int): # <<<<<<<<<<<<<< + * return T + * + */ + __pyx_t_2 = PyObject_IsSubclass(__pyx_v_S, ((PyObject *)(&PyInt_Type))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 1009, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "analysis.py":1010 + * return S + * if issubclass(S, int): + * return T # <<<<<<<<<<<<<< + * + * if issubclass(T, Fraction) and issubclass(S, float): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_T); + __pyx_r = __pyx_v_T; + goto __pyx_L0; + + /* "analysis.py":1009 + * if issubclass(T, int): + * return S + * if issubclass(S, int): # <<<<<<<<<<<<<< + * return T + * + */ + } + + /* "analysis.py":1012 + * return T + * + * if issubclass(T, Fraction) and issubclass(S, float): # <<<<<<<<<<<<<< + * return S + * if issubclass(T, float) and issubclass(S, Fraction): + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Fraction); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1012, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = PyObject_IsSubclass(__pyx_v_T, __pyx_t_4); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 1012, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_3 = PyObject_IsSubclass(__pyx_v_S, ((PyObject *)(&PyFloat_Type))); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 1012, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L13_bool_binop_done:; + if (__pyx_t_1) { + + /* "analysis.py":1013 + * + * if issubclass(T, Fraction) and issubclass(S, float): + * return S # <<<<<<<<<<<<<< + * if issubclass(T, float) and issubclass(S, Fraction): + * return T + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_S); + __pyx_r = __pyx_v_S; + goto __pyx_L0; + + /* "analysis.py":1012 + * return T + * + * if issubclass(T, Fraction) and issubclass(S, float): # <<<<<<<<<<<<<< + * return S + * if issubclass(T, float) and issubclass(S, Fraction): + */ + } + + /* "analysis.py":1014 + * if issubclass(T, Fraction) and issubclass(S, float): + * return S + * if issubclass(T, float) and issubclass(S, Fraction): # <<<<<<<<<<<<<< + * return T + * + */ + __pyx_t_2 = PyObject_IsSubclass(__pyx_v_T, ((PyObject *)(&PyFloat_Type))); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 1014, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L16_bool_binop_done; + } + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Fraction); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1014, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_IsSubclass(__pyx_v_S, __pyx_t_4); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 1014, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L16_bool_binop_done:; + if (__pyx_t_1) { + + /* "analysis.py":1015 + * return S + * if issubclass(T, float) and issubclass(S, Fraction): + * return T # <<<<<<<<<<<<<< + * + * msg = "don't know how to coerce %s and %s" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_T); + __pyx_r = __pyx_v_T; + goto __pyx_L0; + + /* "analysis.py":1014 + * if issubclass(T, Fraction) and issubclass(S, float): + * return S + * if issubclass(T, float) and issubclass(S, Fraction): # <<<<<<<<<<<<<< + * return T + * + */ + } + + /* "analysis.py":1017 + * return T + * + * msg = "don't know how to coerce %s and %s" # <<<<<<<<<<<<<< + * raise TypeError(msg % (T.__name__, S.__name__)) + * + */ + __Pyx_INCREF(__pyx_kp_s_don_t_know_how_to_coerce_s_and_s); + __pyx_v_msg = __pyx_kp_s_don_t_know_how_to_coerce_s_and_s; + + /* "analysis.py":1018 + * + * msg = "don't know how to coerce %s and %s" + * raise TypeError(msg % (T.__name__, S.__name__)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_T, __pyx_n_s_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_S, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Remainder(__pyx_v_msg, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 1018, __pyx_L1_error) + + /* "analysis.py":990 + * + * + * def _coerce(T, S): # <<<<<<<<<<<<<< + * + * assert T is not bool, "initial type T is bool" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("analysis._coerce", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":1021 + * + * + * def _exact_ratio(x): # <<<<<<<<<<<<<< + * + * try: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_49_exact_ratio(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_49_exact_ratio = {"_exact_ratio", (PyCFunction)__pyx_pw_8analysis_49_exact_ratio, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_49_exact_ratio(PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_exact_ratio (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_48_exact_ratio(__pyx_self, ((PyObject *)__pyx_v_x)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_48_exact_ratio(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_v_msg = NULL; + 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_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + __Pyx_RefNannySetupContext("_exact_ratio", 0); + + /* "analysis.py":1023 + * def _exact_ratio(x): + * + * try: # <<<<<<<<<<<<<< + * + * if type(x) is float or type(x) is Decimal: + */ + { + __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:*/ { + + /* "analysis.py":1025 + * try: + * + * if type(x) is float or type(x) is Decimal: # <<<<<<<<<<<<<< + * return x.as_integer_ratio() + * try: + */ + __pyx_t_5 = (((PyObject *)Py_TYPE(__pyx_v_x)) == ((PyObject *)(&PyFloat_Type))); + __pyx_t_6 = (__pyx_t_5 != 0); + if (!__pyx_t_6) { + } else { + __pyx_t_4 = __pyx_t_6; + goto __pyx_L10_bool_binop_done; + } + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_Decimal); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1025, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = (((PyObject *)Py_TYPE(__pyx_v_x)) == __pyx_t_7); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_5 = (__pyx_t_6 != 0); + __pyx_t_4 = __pyx_t_5; + __pyx_L10_bool_binop_done:; + if (__pyx_t_4) { + + /* "analysis.py":1026 + * + * if type(x) is float or type(x) is Decimal: + * return x.as_integer_ratio() # <<<<<<<<<<<<<< + * try: + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_as_integer_ratio); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1026, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + __pyx_t_7 = (__pyx_t_9) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9) : __Pyx_PyObject_CallNoArg(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1026, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L7_try_return; + + /* "analysis.py":1025 + * try: + * + * if type(x) is float or type(x) is Decimal: # <<<<<<<<<<<<<< + * return x.as_integer_ratio() + * try: + */ + } + + /* "analysis.py":1027 + * if type(x) is float or type(x) is Decimal: + * return x.as_integer_ratio() + * try: # <<<<<<<<<<<<<< + * + * return (x.numerator, x.denominator) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + /*try:*/ { + + /* "analysis.py":1029 + * try: + * + * return (x.numerator, x.denominator) # <<<<<<<<<<<<<< + * except AttributeError: + * try: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_numerator); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1029, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_denominator); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1029, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = PyTuple_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1029, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_8); + __pyx_t_7 = 0; + __pyx_t_8 = 0; + __pyx_r = __pyx_t_9; + __pyx_t_9 = 0; + goto __pyx_L16_try_return; + + /* "analysis.py":1027 + * if type(x) is float or type(x) is Decimal: + * return x.as_integer_ratio() + * try: # <<<<<<<<<<<<<< + * + * return (x.numerator, x.denominator) + */ + } + __pyx_L12_error:; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":1030 + * + * return (x.numerator, x.denominator) + * except AttributeError: # <<<<<<<<<<<<<< + * try: + * + */ + __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError); + if (__pyx_t_13) { + __Pyx_AddTraceback("analysis._exact_ratio", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_8, &__pyx_t_7) < 0) __PYX_ERR(0, 1030, __pyx_L14_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_7); + + /* "analysis.py":1031 + * return (x.numerator, x.denominator) + * except AttributeError: + * try: # <<<<<<<<<<<<<< + * + * return x.as_integer_ratio() + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); + __Pyx_XGOTREF(__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_15); + __Pyx_XGOTREF(__pyx_t_16); + /*try:*/ { + + /* "analysis.py":1033 + * try: + * + * return x.as_integer_ratio() # <<<<<<<<<<<<<< + * except AttributeError: + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_as_integer_ratio); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1033, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_19 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_18))) { + __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_18); + if (likely(__pyx_t_19)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_18); + __Pyx_INCREF(__pyx_t_19); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_18, function); + } + } + __pyx_t_17 = (__pyx_t_19) ? __Pyx_PyObject_CallOneArg(__pyx_t_18, __pyx_t_19) : __Pyx_PyObject_CallNoArg(__pyx_t_18); + __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1033, __pyx_L20_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __pyx_r = __pyx_t_17; + __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L24_try_return; + + /* "analysis.py":1031 + * return (x.numerator, x.denominator) + * except AttributeError: + * try: # <<<<<<<<<<<<<< + * + * return x.as_integer_ratio() + */ + } + __pyx_L20_error:; + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + + /* "analysis.py":1034 + * + * return x.as_integer_ratio() + * except AttributeError: # <<<<<<<<<<<<<< + * + * pass + */ + __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError); + if (__pyx_t_13) { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L21_exception_handled; + } + goto __pyx_L22_except_error; + __pyx_L22_except_error:; + + /* "analysis.py":1031 + * return (x.numerator, x.denominator) + * except AttributeError: + * try: # <<<<<<<<<<<<<< + * + * return x.as_integer_ratio() + */ + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); + goto __pyx_L14_except_error; + __pyx_L24_try_return:; + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); + goto __pyx_L15_except_return; + __pyx_L21_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_XGIVEREF(__pyx_t_15); + __Pyx_XGIVEREF(__pyx_t_16); + __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); + } + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L13_exception_handled; + } + goto __pyx_L14_except_error; + __pyx_L14_except_error:; + + /* "analysis.py":1027 + * if type(x) is float or type(x) is Decimal: + * return x.as_integer_ratio() + * try: # <<<<<<<<<<<<<< + * + * return (x.numerator, x.denominator) + */ + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + goto __pyx_L3_error; + __pyx_L16_try_return:; + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + goto __pyx_L7_try_return; + __pyx_L15_except_return:; + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + goto __pyx_L7_try_return; + __pyx_L13_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + } + + /* "analysis.py":1023 + * def _exact_ratio(x): + * + * try: # <<<<<<<<<<<<<< + * + * if type(x) is float or type(x) is Decimal: + */ + } + __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_17); __pyx_t_17 = 0; + __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":1037 + * + * pass + * except (OverflowError, ValueError): # <<<<<<<<<<<<<< + * + * assert not _isfinite(x) + */ + __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OverflowError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError); + if (__pyx_t_13) { + __Pyx_AddTraceback("analysis._exact_ratio", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0) __PYX_ERR(0, 1037, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_9); + + /* "analysis.py":1039 + * except (OverflowError, ValueError): + * + * assert not _isfinite(x) # <<<<<<<<<<<<<< + * return (x, None) + * msg = "can't convert type '{}' to numerator/denominator" + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_n_s_isfinite); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1039, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_19 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_18))) { + __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_18); + if (likely(__pyx_t_19)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_18); + __Pyx_INCREF(__pyx_t_19); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_18, function); + } + } + __pyx_t_17 = (__pyx_t_19) ? __Pyx_PyObject_Call2Args(__pyx_t_18, __pyx_t_19, __pyx_v_x) : __Pyx_PyObject_CallOneArg(__pyx_t_18, __pyx_v_x); + __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1039, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_17); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 1039, __pyx_L5_except_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (unlikely(!((!__pyx_t_4) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(0, 1039, __pyx_L5_except_error) + } + } + #endif + + /* "analysis.py":1040 + * + * assert not _isfinite(x) + * return (x, None) # <<<<<<<<<<<<<< + * msg = "can't convert type '{}' to numerator/denominator" + * raise TypeError(msg.format(type(x).__name__)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_17 = PyTuple_New(2); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 1040, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_INCREF(__pyx_v_x); + __Pyx_GIVEREF(__pyx_v_x); + PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_v_x); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_17, 1, Py_None); + __pyx_r = __pyx_t_17; + __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L6_except_return; + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "analysis.py":1023 + * def _exact_ratio(x): + * + * try: # <<<<<<<<<<<<<< + * + * if type(x) is float or type(x) is Decimal: + */ + __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_L7_try_return:; + __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_L0; + __pyx_L6_except_return:; + __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_L0; + __pyx_L8_try_end:; + } + + /* "analysis.py":1041 + * assert not _isfinite(x) + * return (x, None) + * msg = "can't convert type '{}' to numerator/denominator" # <<<<<<<<<<<<<< + * raise TypeError(msg.format(type(x).__name__)) + * + */ + __Pyx_INCREF(__pyx_kp_s_can_t_convert_type_to_numerator); + __pyx_v_msg = __pyx_kp_s_can_t_convert_type_to_numerator; + + /* "analysis.py":1042 + * return (x, None) + * msg = "can't convert type '{}' to numerator/denominator" + * raise TypeError(msg.format(type(x).__name__)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_msg, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1042, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_x)), __pyx_n_s_name); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1042, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_17 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_17)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_17); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + __pyx_t_9 = (__pyx_t_17) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_17, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1042, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1042, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 1042, __pyx_L1_error) + + /* "analysis.py":1021 + * + * + * def _exact_ratio(x): # <<<<<<<<<<<<<< + * + * try: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_XDECREF(__pyx_t_19); + __Pyx_AddTraceback("analysis._exact_ratio", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":1045 + * + * + * def _convert(value, T): # <<<<<<<<<<<<<< + * + * if type(value) is T: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_51_convert(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_51_convert = {"_convert", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_51_convert, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_51_convert(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_value = 0; + PyObject *__pyx_v_T = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_convert (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,&__pyx_n_s_T,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_value)) != 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_T)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_convert", 1, 2, 2, 1); __PYX_ERR(0, 1045, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_convert") < 0)) __PYX_ERR(0, 1045, __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_value = values[0]; + __pyx_v_T = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_convert", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1045, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis._convert", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_50_convert(__pyx_self, __pyx_v_value, __pyx_v_T); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_50_convert(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_value, PyObject *__pyx_v_T) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __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; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + __Pyx_RefNannySetupContext("_convert", 0); + __Pyx_INCREF(__pyx_v_T); + + /* "analysis.py":1047 + * def _convert(value, T): + * + * if type(value) is T: # <<<<<<<<<<<<<< + * + * return value + */ + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_value)) == __pyx_v_T); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "analysis.py":1049 + * if type(value) is T: + * + * return value # <<<<<<<<<<<<<< + * if issubclass(T, int) and value.denominator != 1: + * T = float + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_value); + __pyx_r = __pyx_v_value; + goto __pyx_L0; + + /* "analysis.py":1047 + * def _convert(value, T): + * + * if type(value) is T: # <<<<<<<<<<<<<< + * + * return value + */ + } + + /* "analysis.py":1050 + * + * return value + * if issubclass(T, int) and value.denominator != 1: # <<<<<<<<<<<<<< + * T = float + * try: + */ + __pyx_t_1 = PyObject_IsSubclass(__pyx_v_T, ((PyObject *)(&PyInt_Type))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 1050, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_denominator); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1050, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_NeObjC(__pyx_t_4, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1050, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1050, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_2 = __pyx_t_3; + __pyx_L5_bool_binop_done:; + if (__pyx_t_2) { + + /* "analysis.py":1051 + * return value + * if issubclass(T, int) and value.denominator != 1: + * T = float # <<<<<<<<<<<<<< + * try: + * + */ + __Pyx_INCREF(((PyObject *)(&PyFloat_Type))); + __Pyx_DECREF_SET(__pyx_v_T, ((PyObject *)(&PyFloat_Type))); + + /* "analysis.py":1050 + * + * return value + * if issubclass(T, int) and value.denominator != 1: # <<<<<<<<<<<<<< + * T = float + * try: + */ + } + + /* "analysis.py":1052 + * if issubclass(T, int) and value.denominator != 1: + * T = float + * try: # <<<<<<<<<<<<<< + * + * return T(value) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + /*try:*/ { + + /* "analysis.py":1054 + * try: + * + * return T(value) # <<<<<<<<<<<<<< + * except TypeError: + * if issubclass(T, Decimal): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_T); + __pyx_t_4 = __pyx_v_T; __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_5 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_9, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_value); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1054, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L11_try_return; + + /* "analysis.py":1052 + * if issubclass(T, int) and value.denominator != 1: + * T = float + * try: # <<<<<<<<<<<<<< + * + * return T(value) + */ + } + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "analysis.py":1055 + * + * return T(value) + * except TypeError: # <<<<<<<<<<<<<< + * if issubclass(T, Decimal): + * return T(value.numerator) / T(value.denominator) + */ + __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); + if (__pyx_t_10) { + __Pyx_AddTraceback("analysis._convert", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_9) < 0) __PYX_ERR(0, 1055, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_t_9); + + /* "analysis.py":1056 + * return T(value) + * except TypeError: + * if issubclass(T, Decimal): # <<<<<<<<<<<<<< + * return T(value.numerator) / T(value.denominator) + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_Decimal); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1056, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_2 = PyObject_IsSubclass(__pyx_v_T, __pyx_t_11); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 1056, __pyx_L9_except_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_3 = (__pyx_t_2 != 0); + if (likely(__pyx_t_3)) { + + /* "analysis.py":1057 + * except TypeError: + * if issubclass(T, Decimal): + * return T(value.numerator) / T(value.denominator) # <<<<<<<<<<<<<< + * else: + * raise + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_numerator); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1057, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_INCREF(__pyx_v_T); + __pyx_t_13 = __pyx_v_T; __pyx_t_14 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_14)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_14); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + } + } + __pyx_t_11 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_14, __pyx_t_12) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_12); + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1057, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_denominator); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1057, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_INCREF(__pyx_v_T); + __pyx_t_14 = __pyx_v_T; __pyx_t_15 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_14))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_14); + if (likely(__pyx_t_15)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14); + __Pyx_INCREF(__pyx_t_15); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_14, function); + } + } + __pyx_t_13 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_14, __pyx_t_15, __pyx_t_12) : __Pyx_PyObject_CallOneArg(__pyx_t_14, __pyx_t_12); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1057, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __pyx_t_14 = __Pyx_PyNumber_Divide(__pyx_t_11, __pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 1057, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_r = __pyx_t_14; + __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L10_except_return; + + /* "analysis.py":1056 + * return T(value) + * except TypeError: + * if issubclass(T, Decimal): # <<<<<<<<<<<<<< + * return T(value.numerator) / T(value.denominator) + * else: + */ + } + + /* "analysis.py":1059 + * return T(value.numerator) / T(value.denominator) + * else: + * raise # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_GIVEREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ErrRestoreWithState(__pyx_t_5, __pyx_t_4, __pyx_t_9); + __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_9 = 0; + __PYX_ERR(0, 1059, __pyx_L9_except_error) + } + } + goto __pyx_L9_except_error; + __pyx_L9_except_error:; + + /* "analysis.py":1052 + * if issubclass(T, int) and value.denominator != 1: + * T = float + * try: # <<<<<<<<<<<<<< + * + * return T(value) + */ + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + goto __pyx_L1_error; + __pyx_L11_try_return:; + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + goto __pyx_L0; + __pyx_L10_except_return:; + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + goto __pyx_L0; + } + + /* "analysis.py":1045 + * + * + * def _convert(value, T): # <<<<<<<<<<<<<< + * + * if type(value) is T: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_AddTraceback("analysis._convert", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_T); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":1062 + * + * + * def _counts(data): # <<<<<<<<<<<<<< + * + * table = collections.Counter(iter(data)).most_common() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_53_counts(PyObject *__pyx_self, PyObject *__pyx_v_data); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_53_counts = {"_counts", (PyCFunction)__pyx_pw_8analysis_53_counts, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_53_counts(PyObject *__pyx_self, PyObject *__pyx_v_data) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_counts (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_52_counts(__pyx_self, ((PyObject *)__pyx_v_data)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_52_counts(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data) { + PyObject *__pyx_v_table = NULL; + PyObject *__pyx_v_maxfreq = NULL; + Py_ssize_t __pyx_v_i; + 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; + int __pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + Py_ssize_t __pyx_t_9; + Py_ssize_t __pyx_t_10; + __Pyx_RefNannySetupContext("_counts", 0); + + /* "analysis.py":1064 + * def _counts(data): + * + * table = collections.Counter(iter(data)).most_common() # <<<<<<<<<<<<<< + * if not table: + * return table + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_collections); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Counter); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyObject_GetIter(__pyx_v_data); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __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_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_most_common); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __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_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_table = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":1065 + * + * table = collections.Counter(iter(data)).most_common() + * if not table: # <<<<<<<<<<<<<< + * return table + * + */ + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_table); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 1065, __pyx_L1_error) + __pyx_t_7 = ((!__pyx_t_6) != 0); + if (__pyx_t_7) { + + /* "analysis.py":1066 + * table = collections.Counter(iter(data)).most_common() + * if not table: + * return table # <<<<<<<<<<<<<< + * + * maxfreq = table[0][1] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_table); + __pyx_r = __pyx_v_table; + goto __pyx_L0; + + /* "analysis.py":1065 + * + * table = collections.Counter(iter(data)).most_common() + * if not table: # <<<<<<<<<<<<<< + * return table + * + */ + } + + /* "analysis.py":1068 + * return table + * + * maxfreq = table[0][1] # <<<<<<<<<<<<<< + * for i in range(1, len(table)): + * if table[i][1] != maxfreq: + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_table, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1068, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1068, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_maxfreq = __pyx_t_4; + __pyx_t_4 = 0; + + /* "analysis.py":1069 + * + * maxfreq = table[0][1] + * for i in range(1, len(table)): # <<<<<<<<<<<<<< + * if table[i][1] != maxfreq: + * table = table[:i] + */ + __pyx_t_8 = PyObject_Length(__pyx_v_table); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1069, __pyx_L1_error) + __pyx_t_9 = __pyx_t_8; + for (__pyx_t_10 = 1; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) { + __pyx_v_i = __pyx_t_10; + + /* "analysis.py":1070 + * maxfreq = table[0][1] + * for i in range(1, len(table)): + * if table[i][1] != maxfreq: # <<<<<<<<<<<<<< + * table = table[:i] + * break + */ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_table, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1070, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1070, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_v_maxfreq, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1070, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 1070, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_7) { + + /* "analysis.py":1071 + * for i in range(1, len(table)): + * if table[i][1] != maxfreq: + * table = table[:i] # <<<<<<<<<<<<<< + * break + * return table + */ + __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_v_table, 0, __pyx_v_i, NULL, NULL, NULL, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1071, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_table, __pyx_t_4); + __pyx_t_4 = 0; + + /* "analysis.py":1072 + * if table[i][1] != maxfreq: + * table = table[:i] + * break # <<<<<<<<<<<<<< + * return table + * + */ + goto __pyx_L5_break; + + /* "analysis.py":1070 + * maxfreq = table[0][1] + * for i in range(1, len(table)): + * if table[i][1] != maxfreq: # <<<<<<<<<<<<<< + * table = table[:i] + * break + */ + } + } + __pyx_L5_break:; + + /* "analysis.py":1073 + * table = table[:i] + * break + * return table # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_table); + __pyx_r = __pyx_v_table; + goto __pyx_L0; + + /* "analysis.py":1062 + * + * + * def _counts(data): # <<<<<<<<<<<<<< + * + * table = collections.Counter(iter(data)).most_common() + */ + + /* 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("analysis._counts", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_table); + __Pyx_XDECREF(__pyx_v_maxfreq); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":1076 + * + * + * def _find_lteq(a, x): # <<<<<<<<<<<<<< + * + * i = bisect_left(a, x) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_55_find_lteq(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_55_find_lteq = {"_find_lteq", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_55_find_lteq, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_55_find_lteq(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_a = 0; + PyObject *__pyx_v_x = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_find_lteq (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_a,&__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_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_x)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_find_lteq", 1, 2, 2, 1); __PYX_ERR(0, 1076, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_find_lteq") < 0)) __PYX_ERR(0, 1076, __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 = values[0]; + __pyx_v_x = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_find_lteq", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1076, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis._find_lteq", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_54_find_lteq(__pyx_self, __pyx_v_a, __pyx_v_x); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_54_find_lteq(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_a, PyObject *__pyx_v_x) { + PyObject *__pyx_v_i = NULL; + 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; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; + int __pyx_t_8; + __Pyx_RefNannySetupContext("_find_lteq", 0); + + /* "analysis.py":1078 + * def _find_lteq(a, x): + * + * i = bisect_left(a, x) # <<<<<<<<<<<<<< + * if i != len(a) and a[i] == x: + * return i + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_bisect_left); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1078, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + 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_4 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_a, __pyx_v_x}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1078, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_a, __pyx_v_x}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1078, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1078, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_INCREF(__pyx_v_a); + __Pyx_GIVEREF(__pyx_v_a); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_v_a); + __Pyx_INCREF(__pyx_v_x); + __Pyx_GIVEREF(__pyx_v_x); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_x); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1078, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_i = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":1079 + * + * i = bisect_left(a, x) + * if i != len(a) and a[i] == x: # <<<<<<<<<<<<<< + * return i + * raise ValueError + */ + __pyx_t_7 = PyObject_Length(__pyx_v_a); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1079, __pyx_L1_error) + __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1079, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_RichCompare(__pyx_v_i, __pyx_t_1, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1079, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 1079, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_8) { + } else { + __pyx_t_6 = __pyx_t_8; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_a, __pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1079, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_v_x, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1079, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 1079, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = __pyx_t_8; + __pyx_L4_bool_binop_done:; + if (__pyx_t_6) { + + /* "analysis.py":1080 + * i = bisect_left(a, x) + * if i != len(a) and a[i] == x: + * return i # <<<<<<<<<<<<<< + * raise ValueError + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_i); + __pyx_r = __pyx_v_i; + goto __pyx_L0; + + /* "analysis.py":1079 + * + * i = bisect_left(a, x) + * if i != len(a) and a[i] == x: # <<<<<<<<<<<<<< + * return i + * raise ValueError + */ + } + + /* "analysis.py":1081 + * if i != len(a) and a[i] == x: + * return i + * raise ValueError # <<<<<<<<<<<<<< + * + * + */ + __Pyx_Raise(__pyx_builtin_ValueError, 0, 0, 0); + __PYX_ERR(0, 1081, __pyx_L1_error) + + /* "analysis.py":1076 + * + * + * def _find_lteq(a, x): # <<<<<<<<<<<<<< + * + * i = bisect_left(a, x) + */ + + /* 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_5); + __Pyx_AddTraceback("analysis._find_lteq", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":1084 + * + * + * def _find_rteq(a, l, x): # <<<<<<<<<<<<<< + * + * i = bisect_right(a, x, lo=l) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_57_find_rteq(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_57_find_rteq = {"_find_rteq", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_57_find_rteq, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_57_find_rteq(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_a = 0; + PyObject *__pyx_v_l = 0; + PyObject *__pyx_v_x = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_find_rteq (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_a,&__pyx_n_s_l,&__pyx_n_s_x,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_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_l)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_find_rteq", 1, 3, 3, 1); __PYX_ERR(0, 1084, __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("_find_rteq", 1, 3, 3, 2); __PYX_ERR(0, 1084, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_find_rteq") < 0)) __PYX_ERR(0, 1084, __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_a = values[0]; + __pyx_v_l = values[1]; + __pyx_v_x = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_find_rteq", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1084, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis._find_rteq", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_56_find_rteq(__pyx_self, __pyx_v_a, __pyx_v_l, __pyx_v_x); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_56_find_rteq(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_a, PyObject *__pyx_v_l, PyObject *__pyx_v_x) { + PyObject *__pyx_v_i = 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; + int __pyx_t_5; + Py_ssize_t __pyx_t_6; + int __pyx_t_7; + __Pyx_RefNannySetupContext("_find_rteq", 0); + + /* "analysis.py":1086 + * def _find_rteq(a, l, x): + * + * i = bisect_right(a, x, lo=l) # <<<<<<<<<<<<<< + * if i != (len(a) + 1) and a[i - 1] == x: + * return i - 1 + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_bisect_right); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_a); + __Pyx_GIVEREF(__pyx_v_a); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_a); + __Pyx_INCREF(__pyx_v_x); + __Pyx_GIVEREF(__pyx_v_x); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_x); + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_lo, __pyx_v_l) < 0) __PYX_ERR(0, 1086, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __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; + __pyx_v_i = __pyx_t_4; + __pyx_t_4 = 0; + + /* "analysis.py":1087 + * + * i = bisect_right(a, x, lo=l) + * if i != (len(a) + 1) and a[i - 1] == x: # <<<<<<<<<<<<<< + * return i - 1 + * raise ValueError + */ + __pyx_t_6 = PyObject_Length(__pyx_v_a); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1087, __pyx_L1_error) + __pyx_t_4 = PyInt_FromSsize_t((__pyx_t_6 + 1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1087, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_i, __pyx_t_4, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1087, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 1087, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_7) { + } else { + __pyx_t_5 = __pyx_t_7; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_PyInt_SubtractObjC(__pyx_v_i, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1087, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1087, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_v_x, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1087, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 1087, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_t_7; + __pyx_L4_bool_binop_done:; + if (__pyx_t_5) { + + /* "analysis.py":1088 + * i = bisect_right(a, x, lo=l) + * if i != (len(a) + 1) and a[i - 1] == x: + * return i - 1 # <<<<<<<<<<<<<< + * raise ValueError + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_PyInt_SubtractObjC(__pyx_v_i, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "analysis.py":1087 + * + * i = bisect_right(a, x, lo=l) + * if i != (len(a) + 1) and a[i - 1] == x: # <<<<<<<<<<<<<< + * return i - 1 + * raise ValueError + */ + } + + /* "analysis.py":1089 + * if i != (len(a) + 1) and a[i - 1] == x: + * return i - 1 + * raise ValueError # <<<<<<<<<<<<<< + * + * + */ + __Pyx_Raise(__pyx_builtin_ValueError, 0, 0, 0); + __PYX_ERR(0, 1089, __pyx_L1_error) + + /* "analysis.py":1084 + * + * + * def _find_rteq(a, l, x): # <<<<<<<<<<<<<< + * + * i = bisect_right(a, x, lo=l) + */ + + /* 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("analysis._find_rteq", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_8analysis_60generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "analysis.py":1092 + * + * + * def _fail_neg(values, errmsg='negative value'): # <<<<<<<<<<<<<< + * + * for x in values: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_59_fail_neg(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_59_fail_neg = {"_fail_neg", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_59_fail_neg, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_59_fail_neg(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_values = 0; + PyObject *__pyx_v_errmsg = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_fail_neg (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_values,&__pyx_n_s_errmsg,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)((PyObject*)__pyx_kp_s_negative_value)); + 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_values)) != 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_errmsg); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_fail_neg") < 0)) __PYX_ERR(0, 1092, __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_values = values[0]; + __pyx_v_errmsg = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_fail_neg", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1092, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis._fail_neg", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_58_fail_neg(__pyx_self, __pyx_v_values, __pyx_v_errmsg); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_58_fail_neg(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_values, PyObject *__pyx_v_errmsg) { + struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_fail_neg", 0); + __pyx_cur_scope = (struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg *)__pyx_tp_new_8analysis___pyx_scope_struct_2__fail_neg(__pyx_ptype_8analysis___pyx_scope_struct_2__fail_neg, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 1092, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_v_values = __pyx_v_values; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_values); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_values); + __pyx_cur_scope->__pyx_v_errmsg = __pyx_v_errmsg; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_errmsg); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_errmsg); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_8analysis_60generator, __pyx_codeobj__16, (PyObject *) __pyx_cur_scope, __pyx_n_s_fail_neg, __pyx_n_s_fail_neg, __pyx_n_s_analysis); if (unlikely(!gen)) __PYX_ERR(0, 1092, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("analysis._fail_neg", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_8analysis_60generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg *__pyx_cur_scope = ((struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_fail_neg", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L7_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1092, __pyx_L1_error) + + /* "analysis.py":1094 + * def _fail_neg(values, errmsg='negative value'): + * + * for x in values: # <<<<<<<<<<<<<< + * if x < 0: + * raise StatisticsError(errmsg) + */ + if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_v_values)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_v_values)) { + __pyx_t_1 = __pyx_cur_scope->__pyx_v_values; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_v_values); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1094, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 1094, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 1094, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 1094, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_x); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_x, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "analysis.py":1095 + * + * for x in values: + * if x < 0: # <<<<<<<<<<<<<< + * raise StatisticsError(errmsg) + * yield x + */ + __pyx_t_4 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_x, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1095, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 1095, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(__pyx_t_5)) { + + /* "analysis.py":1096 + * for x in values: + * if x < 0: + * raise StatisticsError(errmsg) # <<<<<<<<<<<<<< + * yield x + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_StatisticsError); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_cur_scope->__pyx_v_errmsg) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_cur_scope->__pyx_v_errmsg); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 1096, __pyx_L1_error) + + /* "analysis.py":1095 + * + * for x in values: + * if x < 0: # <<<<<<<<<<<<<< + * raise StatisticsError(errmsg) + * yield x + */ + } + + /* "analysis.py":1097 + * if x < 0: + * raise StatisticsError(errmsg) + * yield x # <<<<<<<<<<<<<< + * + * + */ + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_x); + __pyx_r = __pyx_cur_scope->__pyx_v_x; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L7_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1097, __pyx_L1_error) + + /* "analysis.py":1094 + * def _fail_neg(values, errmsg='negative value'): + * + * for x in values: # <<<<<<<<<<<<<< + * if x < 0: + * raise StatisticsError(errmsg) + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* "analysis.py":1092 + * + * + * def _fail_neg(values, errmsg='negative value'): # <<<<<<<<<<<<<< + * + * for x in values: + */ + + /* function exit code */ + PyErr_SetNone(PyExc_StopIteration); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("_fail_neg", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":1100 + * + * + * def mean(data): # <<<<<<<<<<<<<< + * + * if iter(data) is data: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_62mean(PyObject *__pyx_self, PyObject *__pyx_v_data); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_62mean = {"mean", (PyCFunction)__pyx_pw_8analysis_62mean, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_62mean(PyObject *__pyx_self, PyObject *__pyx_v_data) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("mean (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_61mean(__pyx_self, ((PyObject *)__pyx_v_data)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_61mean(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_T = NULL; + PyObject *__pyx_v_total = NULL; + PyObject *__pyx_v_count = NULL; + PyObject *__pyx_r = NULL; + __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 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *(*__pyx_t_9)(PyObject *); + int __pyx_t_10; + __Pyx_RefNannySetupContext("mean", 0); + __Pyx_INCREF(__pyx_v_data); + + /* "analysis.py":1102 + * def mean(data): + * + * if iter(data) is data: # <<<<<<<<<<<<<< + * data = list(data) + * n = len(data) + */ + __pyx_t_1 = PyObject_GetIter(__pyx_v_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__pyx_t_1 == __pyx_v_data); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "analysis.py":1103 + * + * if iter(data) is data: + * data = list(data) # <<<<<<<<<<<<<< + * n = len(data) + * if n < 1: + */ + __pyx_t_1 = PySequence_List(__pyx_v_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_data, __pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":1102 + * def mean(data): + * + * if iter(data) is data: # <<<<<<<<<<<<<< + * data = list(data) + * n = len(data) + */ + } + + /* "analysis.py":1104 + * if iter(data) is data: + * data = list(data) + * n = len(data) # <<<<<<<<<<<<<< + * if n < 1: + * raise StatisticsError('mean requires at least one data point') + */ + __pyx_t_4 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1104, __pyx_L1_error) + __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":1105 + * data = list(data) + * n = len(data) + * if n < 1: # <<<<<<<<<<<<<< + * raise StatisticsError('mean requires at least one data point') + * T, total, count = _sum(data) + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_n, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1105, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1105, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(__pyx_t_3)) { + + /* "analysis.py":1106 + * n = len(data) + * if n < 1: + * raise StatisticsError('mean requires at least one data point') # <<<<<<<<<<<<<< + * T, total, count = _sum(data) + * assert count == n + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_StatisticsError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_kp_s_mean_requires_at_least_one_data) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_kp_s_mean_requires_at_least_one_data); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 1106, __pyx_L1_error) + + /* "analysis.py":1105 + * data = list(data) + * n = len(data) + * if n < 1: # <<<<<<<<<<<<<< + * raise StatisticsError('mean requires at least one data point') + * T, total, count = _sum(data) + */ + } + + /* "analysis.py":1107 + * if n < 1: + * raise StatisticsError('mean requires at least one data point') + * T, total, count = _sum(data) # <<<<<<<<<<<<<< + * assert count == n + * return _convert(total / n, T) + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_sum_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_v_data) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_data); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 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 != 3)) { + if (size > 3) __Pyx_RaiseTooManyValuesError(3); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 1107, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_5 = PyList_GET_ITEM(sequence, 0); + __pyx_t_6 = PyList_GET_ITEM(sequence, 1); + __pyx_t_7 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + #else + __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_9 = Py_TYPE(__pyx_t_8)->tp_iternext; + index = 0; __pyx_t_5 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 1; __pyx_t_6 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + index = 2; __pyx_t_7 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 3) < 0) __PYX_ERR(0, 1107, __pyx_L1_error) + __pyx_t_9 = NULL; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 1107, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __pyx_v_T = __pyx_t_5; + __pyx_t_5 = 0; + __pyx_v_total = __pyx_t_6; + __pyx_t_6 = 0; + __pyx_v_count = __pyx_t_7; + __pyx_t_7 = 0; + + /* "analysis.py":1108 + * raise StatisticsError('mean requires at least one data point') + * T, total, count = _sum(data) + * assert count == n # <<<<<<<<<<<<<< + * return _convert(total / n, T) + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + __pyx_t_1 = PyObject_RichCompare(__pyx_v_count, __pyx_v_n, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1108, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1108, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(0, 1108, __pyx_L1_error) + } + } + #endif + + /* "analysis.py":1109 + * T, total, count = _sum(data) + * assert count == n + * return _convert(total / n, T) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_convert); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_v_total, __pyx_v_n); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_6, __pyx_v_T}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1109, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_6, __pyx_v_T}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1109, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_10, __pyx_t_6); + __Pyx_INCREF(__pyx_v_T); + __Pyx_GIVEREF(__pyx_v_T); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_10, __pyx_v_T); + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "analysis.py":1100 + * + * + * def mean(data): # <<<<<<<<<<<<<< + * + * if iter(data) is data: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("analysis.mean", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_T); + __Pyx_XDECREF(__pyx_v_total); + __Pyx_XDECREF(__pyx_v_count); + __Pyx_XDECREF(__pyx_v_data); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":1112 + * + * + * def median(data): # <<<<<<<<<<<<<< + * + * data = sorted(data) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_64median(PyObject *__pyx_self, PyObject *__pyx_v_data); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_64median = {"median", (PyCFunction)__pyx_pw_8analysis_64median, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_64median(PyObject *__pyx_self, PyObject *__pyx_v_data) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("median (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_63median(__pyx_self, ((PyObject *)__pyx_v_data)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_63median(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("median", 0); + __Pyx_INCREF(__pyx_v_data); + + /* "analysis.py":1114 + * def median(data): + * + * data = sorted(data) # <<<<<<<<<<<<<< + * n = len(data) + * if n == 0: + */ + __pyx_t_2 = PySequence_List(__pyx_v_data); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_3 = PyList_Sort(__pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 1114, __pyx_L1_error) + __Pyx_DECREF_SET(__pyx_v_data, __pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":1115 + * + * data = sorted(data) + * n = len(data) # <<<<<<<<<<<<<< + * if n == 0: + * raise StatisticsError("no median for empty data") + */ + __pyx_t_4 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1115, __pyx_L1_error) + __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":1116 + * data = sorted(data) + * n = len(data) + * if n == 0: # <<<<<<<<<<<<<< + * raise StatisticsError("no median for empty data") + * if n % 2 == 1: + */ + __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_n, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 1116, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(__pyx_t_5)) { + + /* "analysis.py":1117 + * n = len(data) + * if n == 0: + * raise StatisticsError("no median for empty data") # <<<<<<<<<<<<<< + * if n % 2 == 1: + * return data[n // 2] + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_StatisticsError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_6, __pyx_kp_s_no_median_for_empty_data) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_s_no_median_for_empty_data); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 1117, __pyx_L1_error) + + /* "analysis.py":1116 + * data = sorted(data) + * n = len(data) + * if n == 0: # <<<<<<<<<<<<<< + * raise StatisticsError("no median for empty data") + * if n % 2 == 1: + */ + } + + /* "analysis.py":1118 + * if n == 0: + * raise StatisticsError("no median for empty data") + * if n % 2 == 1: # <<<<<<<<<<<<<< + * return data[n // 2] + * else: + */ + __pyx_t_1 = __Pyx_PyInt_RemainderObjC(__pyx_v_n, __pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 1118, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + + /* "analysis.py":1119 + * raise StatisticsError("no median for empty data") + * if n % 2 == 1: + * return data[n // 2] # <<<<<<<<<<<<<< + * else: + * i = n // 2 + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_FloorDivideObjC(__pyx_v_n, __pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_data, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1119, __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; + + /* "analysis.py":1118 + * if n == 0: + * raise StatisticsError("no median for empty data") + * if n % 2 == 1: # <<<<<<<<<<<<<< + * return data[n // 2] + * else: + */ + } + + /* "analysis.py":1121 + * return data[n // 2] + * else: + * i = n // 2 # <<<<<<<<<<<<<< + * return (data[i - 1] + data[i]) / 2 + * + */ + /*else*/ { + __pyx_t_1 = __Pyx_PyInt_FloorDivideObjC(__pyx_v_n, __pyx_int_2, 2, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_i = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":1122 + * else: + * i = n // 2 + * return (data[i - 1] + data[i]) / 2 # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_SubtractObjC(__pyx_v_i, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_data, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_data, __pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = PyNumber_Add(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_6, __pyx_int_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + } + + /* "analysis.py":1112 + * + * + * def median(data): # <<<<<<<<<<<<<< + * + * data = sorted(data) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("analysis.median", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_data); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":1125 + * + * + * def mode(data): # <<<<<<<<<<<<<< + * + * table = _counts(data) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_66mode(PyObject *__pyx_self, PyObject *__pyx_v_data); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_66mode = {"mode", (PyCFunction)__pyx_pw_8analysis_66mode, METH_O, 0}; +static PyObject *__pyx_pw_8analysis_66mode(PyObject *__pyx_self, PyObject *__pyx_v_data) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("mode (wrapper)", 0); + __pyx_r = __pyx_pf_8analysis_65mode(__pyx_self, ((PyObject *)__pyx_v_data)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_65mode(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data) { + PyObject *__pyx_v_table = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("mode", 0); + + /* "analysis.py":1127 + * def mode(data): + * + * table = _counts(data) # <<<<<<<<<<<<<< + * if len(table) == 1: + * return table[0][0] + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_counts); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __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_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_data) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_data); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_table = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":1128 + * + * table = _counts(data) + * if len(table) == 1: # <<<<<<<<<<<<<< + * return table[0][0] + * elif table: + */ + __pyx_t_4 = PyObject_Length(__pyx_v_table); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1128, __pyx_L1_error) + __pyx_t_5 = ((__pyx_t_4 == 1) != 0); + if (__pyx_t_5) { + + /* "analysis.py":1129 + * table = _counts(data) + * if len(table) == 1: + * return table[0][0] # <<<<<<<<<<<<<< + * elif table: + * raise StatisticsError( + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_table, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __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(0, 1129, __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; + + /* "analysis.py":1128 + * + * table = _counts(data) + * if len(table) == 1: # <<<<<<<<<<<<<< + * return table[0][0] + * elif table: + */ + } + + /* "analysis.py":1130 + * if len(table) == 1: + * return table[0][0] + * elif table: # <<<<<<<<<<<<<< + * raise StatisticsError( + * 'no unique mode; found %d equally common values' % len(table) + */ + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_table); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 1130, __pyx_L1_error) + if (unlikely(__pyx_t_5)) { + + /* "analysis.py":1131 + * return table[0][0] + * elif table: + * raise StatisticsError( # <<<<<<<<<<<<<< + * 'no unique mode; found %d equally common values' % len(table) + * ) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_StatisticsError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "analysis.py":1132 + * elif table: + * raise StatisticsError( + * 'no unique mode; found %d equally common values' % len(table) # <<<<<<<<<<<<<< + * ) + * else: + */ + __pyx_t_4 = PyObject_Length(__pyx_v_table); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1132, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_no_unique_mode_found_d_equally_c, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1132, __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 && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1131, __pyx_L1_error) + + /* "analysis.py":1130 + * if len(table) == 1: + * return table[0][0] + * elif table: # <<<<<<<<<<<<<< + * raise StatisticsError( + * 'no unique mode; found %d equally common values' % len(table) + */ + } + + /* "analysis.py":1135 + * ) + * else: + * raise StatisticsError('no mode for empty data') # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_StatisticsError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_kp_s_no_mode_for_empty_data) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_kp_s_no_mode_for_empty_data); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1135, __pyx_L1_error) + } + + /* "analysis.py":1125 + * + * + * def mode(data): # <<<<<<<<<<<<<< + * + * table = _counts(data) + */ + + /* 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_6); + __Pyx_AddTraceback("analysis.mode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_table); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":1138 + * + * + * def _ss(data, c=None): # <<<<<<<<<<<<<< + * + * if c is None: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_68_ss(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_68_ss = {"_ss", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_68_ss, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_68_ss(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_data = 0; + PyObject *__pyx_v_c = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_ss (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_data,&__pyx_n_s_c,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)((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_data)) != 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_c); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_ss") < 0)) __PYX_ERR(0, 1138, __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_data = values[0]; + __pyx_v_c = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_ss", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1138, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis._ss", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_67_ss(__pyx_self, __pyx_v_data, __pyx_v_c); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_8analysis_3_ss_2generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "analysis.py":1142 + * if c is None: + * c = mean(data) + * T, total, count = _sum((x - c)**2 for x in data) # <<<<<<<<<<<<<< + * + * U, total2, count2 = _sum((x - c) for x in data) + */ + +static PyObject *__pyx_pf_8analysis_3_ss_genexpr(PyObject *__pyx_self) { + struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr *)__pyx_tp_new_8analysis___pyx_scope_struct_4_genexpr(__pyx_ptype_8analysis___pyx_scope_struct_4_genexpr, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 1142, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *) __pyx_self; + __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_8analysis_3_ss_2generator2, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_ss_locals_genexpr, __pyx_n_s_analysis); if (unlikely(!gen)) __PYX_ERR(0, 1142, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("analysis._ss.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_8analysis_3_ss_2generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr *__pyx_cur_scope = ((struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L6_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1142, __pyx_L1_error) + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_data)) { __Pyx_RaiseClosureNameError("data"); __PYX_ERR(0, 1142, __pyx_L1_error) } + if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_data)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_data)) { + __pyx_t_1 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_data; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1142, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 1142, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 1142, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 1142, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_x); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_x, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_c)) { __Pyx_RaiseClosureNameError("c"); __PYX_ERR(0, 1142, __pyx_L1_error) } + __pyx_t_4 = PyNumber_Subtract(__pyx_cur_scope->__pyx_v_x, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_c); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyNumber_Power(__pyx_t_4, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L6_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1142, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + PyErr_SetNone(PyExc_StopIteration); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_8analysis_3_ss_5generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "analysis.py":1144 + * T, total, count = _sum((x - c)**2 for x in data) + * + * U, total2, count2 = _sum((x - c) for x in data) # <<<<<<<<<<<<<< + * assert T == U and count == count2 + * total -= total2**2 / len(data) + */ + +static PyObject *__pyx_pf_8analysis_3_ss_3genexpr(PyObject *__pyx_self) { + struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr *)__pyx_tp_new_8analysis___pyx_scope_struct_5_genexpr(__pyx_ptype_8analysis___pyx_scope_struct_5_genexpr, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 1144, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *) __pyx_self; + __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_8analysis_3_ss_5generator3, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_ss_locals_genexpr, __pyx_n_s_analysis); if (unlikely(!gen)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("analysis._ss.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_8analysis_3_ss_5generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr *__pyx_cur_scope = ((struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L6_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1144, __pyx_L1_error) + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_data)) { __Pyx_RaiseClosureNameError("data"); __PYX_ERR(0, 1144, __pyx_L1_error) } + if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_data)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_data)) { + __pyx_t_1 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_data; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1144, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 1144, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 1144, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 1144, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_x); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_x, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_c)) { __Pyx_RaiseClosureNameError("c"); __PYX_ERR(0, 1144, __pyx_L1_error) } + __pyx_t_4 = PyNumber_Subtract(__pyx_cur_scope->__pyx_v_x, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_c); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L6_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1144, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + PyErr_SetNone(PyExc_StopIteration); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":1138 + * + * + * def _ss(data, c=None): # <<<<<<<<<<<<<< + * + * if c is None: + */ + +static PyObject *__pyx_pf_8analysis_67_ss(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data, PyObject *__pyx_v_c) { + struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *__pyx_cur_scope; + PyObject *__pyx_v_T = NULL; + PyObject *__pyx_v_total = NULL; + PyObject *__pyx_v_count = NULL; + PyObject *__pyx_v_U = NULL; + PyObject *__pyx_v_total2 = NULL; + PyObject *__pyx_v_count2 = 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; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *(*__pyx_t_8)(PyObject *); + Py_ssize_t __pyx_t_9; + __Pyx_RefNannySetupContext("_ss", 0); + __pyx_cur_scope = (struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *)__pyx_tp_new_8analysis___pyx_scope_struct_3__ss(__pyx_ptype_8analysis___pyx_scope_struct_3__ss, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 1138, __pyx_L1_error) + } else { + __Pyx_GOTREF(__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_v_data = __pyx_v_data; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_data); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_data); + __pyx_cur_scope->__pyx_v_c = __pyx_v_c; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_c); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_c); + + /* "analysis.py":1140 + * def _ss(data, c=None): + * + * if c is None: # <<<<<<<<<<<<<< + * c = mean(data) + * T, total, count = _sum((x - c)**2 for x in data) + */ + __pyx_t_1 = (__pyx_cur_scope->__pyx_v_c == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "analysis.py":1141 + * + * if c is None: + * c = mean(data) # <<<<<<<<<<<<<< + * T, total, count = _sum((x - c)**2 for x in data) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_mean); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __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_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_cur_scope->__pyx_v_data) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_cur_scope->__pyx_v_data); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_c); + __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_c, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + + /* "analysis.py":1140 + * def _ss(data, c=None): + * + * if c is None: # <<<<<<<<<<<<<< + * c = mean(data) + * T, total, count = _sum((x - c)**2 for x in data) + */ + } + + /* "analysis.py":1142 + * if c is None: + * c = mean(data) + * T, total, count = _sum((x - c)**2 for x in data) # <<<<<<<<<<<<<< + * + * U, total2, count2 = _sum((x - c) for x in data) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_sum_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __pyx_pf_8analysis_3_ss_genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + 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(0, 1142, __pyx_L1_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); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_4 = PyList_GET_ITEM(sequence, 0); + __pyx_t_5 = PyList_GET_ITEM(sequence, 1); + __pyx_t_6 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + #else + __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_7 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; + index = 0; __pyx_t_4 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_4)) goto __pyx_L4_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_5 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L4_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 2; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L4_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 3) < 0) __PYX_ERR(0, 1142, __pyx_L1_error) + __pyx_t_8 = NULL; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L5_unpacking_done; + __pyx_L4_unpacking_failed:; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 1142, __pyx_L1_error) + __pyx_L5_unpacking_done:; + } + __pyx_v_T = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_v_total = __pyx_t_5; + __pyx_t_5 = 0; + __pyx_v_count = __pyx_t_6; + __pyx_t_6 = 0; + + /* "analysis.py":1144 + * T, total, count = _sum((x - c)**2 for x in data) + * + * U, total2, count2 = _sum((x - c) for x in data) # <<<<<<<<<<<<<< + * assert T == U and count == count2 + * total -= total2**2 / len(data) + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_sum_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __pyx_pf_8analysis_3_ss_3genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + 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(0, 1144, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_6 = PyList_GET_ITEM(sequence, 0); + __pyx_t_5 = PyList_GET_ITEM(sequence, 1); + __pyx_t_4 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_7 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; + index = 0; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + index = 1; __pyx_t_5 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 2; __pyx_t_4 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_4)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 3) < 0) __PYX_ERR(0, 1144, __pyx_L1_error) + __pyx_t_8 = NULL; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L7_unpacking_done; + __pyx_L6_unpacking_failed:; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 1144, __pyx_L1_error) + __pyx_L7_unpacking_done:; + } + __pyx_v_U = __pyx_t_6; + __pyx_t_6 = 0; + __pyx_v_total2 = __pyx_t_5; + __pyx_t_5 = 0; + __pyx_v_count2 = __pyx_t_4; + __pyx_t_4 = 0; + + /* "analysis.py":1145 + * + * U, total2, count2 = _sum((x - c) for x in data) + * assert T == U and count == count2 # <<<<<<<<<<<<<< + * total -= total2**2 / len(data) + * assert not total < 0, 'negative sum of square deviations: %f' % total + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + __pyx_t_3 = PyObject_RichCompare(__pyx_v_T, __pyx_v_U, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1145, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1145, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L8_bool_binop_done; + } + __pyx_t_3 = PyObject_RichCompare(__pyx_v_count, __pyx_v_count2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1145, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1145, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __pyx_t_1; + __pyx_L8_bool_binop_done:; + if (unlikely(!__pyx_t_2)) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(0, 1145, __pyx_L1_error) + } + } + #endif + + /* "analysis.py":1146 + * U, total2, count2 = _sum((x - c) for x in data) + * assert T == U and count == count2 + * total -= total2**2 / len(data) # <<<<<<<<<<<<<< + * assert not total < 0, 'negative sum of square deviations: %f' % total + * return (T, total) + */ + __pyx_t_3 = PyNumber_Power(__pyx_v_total2, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_cur_scope->__pyx_v_data; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_9 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1146, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_InPlaceSubtract(__pyx_v_total, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF_SET(__pyx_v_total, __pyx_t_4); + __pyx_t_4 = 0; + + /* "analysis.py":1147 + * assert T == U and count == count2 + * total -= total2**2 / len(data) + * assert not total < 0, 'negative sum of square deviations: %f' % total # <<<<<<<<<<<<<< + * return (T, total) + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + __pyx_t_4 = PyObject_RichCompare(__pyx_v_total, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1147, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1147, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!((!__pyx_t_2) != 0))) { + __pyx_t_4 = __Pyx_PyString_FormatSafe(__pyx_kp_s_negative_sum_of_square_deviation, __pyx_v_total); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + PyErr_SetObject(PyExc_AssertionError, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 1147, __pyx_L1_error) + } + } + #endif + + /* "analysis.py":1148 + * total -= total2**2 / len(data) + * assert not total < 0, 'negative sum of square deviations: %f' % total + * return (T, total) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_T); + __Pyx_GIVEREF(__pyx_v_T); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_T); + __Pyx_INCREF(__pyx_v_total); + __Pyx_GIVEREF(__pyx_v_total); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_total); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "analysis.py":1138 + * + * + * def _ss(data, c=None): # <<<<<<<<<<<<<< + * + * if c is None: + */ + + /* 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("analysis._ss", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_T); + __Pyx_XDECREF(__pyx_v_total); + __Pyx_XDECREF(__pyx_v_count); + __Pyx_XDECREF(__pyx_v_U); + __Pyx_XDECREF(__pyx_v_total2); + __Pyx_XDECREF(__pyx_v_count2); + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":1151 + * + * + * def variance(data, xbar=None): # <<<<<<<<<<<<<< + * + * if iter(data) is data: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_70variance(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_70variance = {"variance", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_70variance, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_70variance(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_data = 0; + PyObject *__pyx_v_xbar = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("variance (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_data,&__pyx_n_s_xbar,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)((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_data)) != 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_xbar); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "variance") < 0)) __PYX_ERR(0, 1151, __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_data = values[0]; + __pyx_v_xbar = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("variance", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1151, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.variance", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_69variance(__pyx_self, __pyx_v_data, __pyx_v_xbar); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_69variance(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data, PyObject *__pyx_v_xbar) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_T = NULL; + PyObject *__pyx_v_ss = NULL; + PyObject *__pyx_r = NULL; + __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 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *(*__pyx_t_9)(PyObject *); + PyObject *__pyx_t_10 = NULL; + __Pyx_RefNannySetupContext("variance", 0); + __Pyx_INCREF(__pyx_v_data); + + /* "analysis.py":1153 + * def variance(data, xbar=None): + * + * if iter(data) is data: # <<<<<<<<<<<<<< + * data = list(data) + * n = len(data) + */ + __pyx_t_1 = PyObject_GetIter(__pyx_v_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__pyx_t_1 == __pyx_v_data); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "analysis.py":1154 + * + * if iter(data) is data: + * data = list(data) # <<<<<<<<<<<<<< + * n = len(data) + * if n < 2: + */ + __pyx_t_1 = PySequence_List(__pyx_v_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_data, __pyx_t_1); + __pyx_t_1 = 0; + + /* "analysis.py":1153 + * def variance(data, xbar=None): + * + * if iter(data) is data: # <<<<<<<<<<<<<< + * data = list(data) + * n = len(data) + */ + } + + /* "analysis.py":1155 + * if iter(data) is data: + * data = list(data) + * n = len(data) # <<<<<<<<<<<<<< + * if n < 2: + * raise StatisticsError('variance requires at least two data points') + */ + __pyx_t_4 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1155, __pyx_L1_error) + __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":1156 + * data = list(data) + * n = len(data) + * if n < 2: # <<<<<<<<<<<<<< + * raise StatisticsError('variance requires at least two data points') + * T, ss = _ss(data, xbar) + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_n, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1156, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1156, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(__pyx_t_3)) { + + /* "analysis.py":1157 + * n = len(data) + * if n < 2: + * raise StatisticsError('variance requires at least two data points') # <<<<<<<<<<<<<< + * T, ss = _ss(data, xbar) + * return _convert(ss / (n - 1), T) + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_StatisticsError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_kp_s_variance_requires_at_least_two_d) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_kp_s_variance_requires_at_least_two_d); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 1157, __pyx_L1_error) + + /* "analysis.py":1156 + * data = list(data) + * n = len(data) + * if n < 2: # <<<<<<<<<<<<<< + * raise StatisticsError('variance requires at least two data points') + * T, ss = _ss(data, xbar) + */ + } + + /* "analysis.py":1158 + * if n < 2: + * raise StatisticsError('variance requires at least two data points') + * T, ss = _ss(data, xbar) # <<<<<<<<<<<<<< + * return _convert(ss / (n - 1), T) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_ss); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_v_data, __pyx_v_xbar}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1158, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_v_data, __pyx_v_xbar}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1158, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_INCREF(__pyx_v_data); + __Pyx_GIVEREF(__pyx_v_data); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_v_data); + __Pyx_INCREF(__pyx_v_xbar); + __Pyx_GIVEREF(__pyx_v_xbar); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_xbar); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 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(0, 1158, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_5 = PyList_GET_ITEM(sequence, 0); + __pyx_t_8 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx_t_8); + #else + __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_9 = Py_TYPE(__pyx_t_6)->tp_iternext; + index = 0; __pyx_t_5 = __pyx_t_9(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 1; __pyx_t_8 = __pyx_t_9(__pyx_t_6); if (unlikely(!__pyx_t_8)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_6), 2) < 0) __PYX_ERR(0, 1158, __pyx_L1_error) + __pyx_t_9 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_9 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 1158, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __pyx_v_T = __pyx_t_5; + __pyx_t_5 = 0; + __pyx_v_ss = __pyx_t_8; + __pyx_t_8 = 0; + + /* "analysis.py":1159 + * raise StatisticsError('variance requires at least two data points') + * T, ss = _ss(data, xbar) + * return _convert(ss / (n - 1), T) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_convert); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyInt_SubtractObjC(__pyx_v_n, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_v_ss, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(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_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_6, __pyx_v_T}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1159, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_6, __pyx_v_T}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1159, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_7, __pyx_t_6); + __Pyx_INCREF(__pyx_v_T); + __Pyx_GIVEREF(__pyx_v_T); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_7, __pyx_v_T); + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "analysis.py":1151 + * + * + * def variance(data, xbar=None): # <<<<<<<<<<<<<< + * + * if iter(data) is data: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("analysis.variance", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_T); + __Pyx_XDECREF(__pyx_v_ss); + __Pyx_XDECREF(__pyx_v_data); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "analysis.py":1162 + * + * + * def stdev(data, xbar=None): # <<<<<<<<<<<<<< + * + * var = variance(data, xbar) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_8analysis_72stdev(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_8analysis_72stdev = {"stdev", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8analysis_72stdev, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_8analysis_72stdev(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_data = 0; + PyObject *__pyx_v_xbar = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("stdev (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_data,&__pyx_n_s_xbar,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)((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_data)) != 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_xbar); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stdev") < 0)) __PYX_ERR(0, 1162, __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_data = values[0]; + __pyx_v_xbar = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("stdev", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1162, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("analysis.stdev", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_8analysis_71stdev(__pyx_self, __pyx_v_data, __pyx_v_xbar); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_8analysis_71stdev(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_data, PyObject *__pyx_v_xbar) { + PyObject *__pyx_v_var = NULL; + 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; + 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; + __Pyx_RefNannySetupContext("stdev", 0); + + /* "analysis.py":1164 + * def stdev(data, xbar=None): + * + * var = variance(data, xbar) # <<<<<<<<<<<<<< + * try: + * return var.sqrt() + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_variance); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + 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_4 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_data, __pyx_v_xbar}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1164, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_data, __pyx_v_xbar}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1164, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_INCREF(__pyx_v_data); + __Pyx_GIVEREF(__pyx_v_data); + PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_v_data); + __Pyx_INCREF(__pyx_v_xbar); + __Pyx_GIVEREF(__pyx_v_xbar); + PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_xbar); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_var = __pyx_t_1; + __pyx_t_1 = 0; + + /* "analysis.py":1165 + * + * var = variance(data, xbar) + * try: # <<<<<<<<<<<<<< + * return var.sqrt() + * except AttributeError: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + /*try:*/ { + + /* "analysis.py":1166 + * var = variance(data, xbar) + * try: + * return var.sqrt() # <<<<<<<<<<<<<< + * except AttributeError: + * return math.sqrt(var) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1166, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1166, __pyx_L3_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_L7_try_return; + + /* "analysis.py":1165 + * + * var = variance(data, xbar) + * try: # <<<<<<<<<<<<<< + * return var.sqrt() + * except AttributeError: + */ + } + __pyx_L3_error:; + __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; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "analysis.py":1167 + * try: + * return var.sqrt() + * except AttributeError: # <<<<<<<<<<<<<< + * return math.sqrt(var) + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError); + if (__pyx_t_4) { + __Pyx_AddTraceback("analysis.stdev", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_5) < 0) __PYX_ERR(0, 1167, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_5); + + /* "analysis.py":1168 + * return var.sqrt() + * except AttributeError: + * return math.sqrt(var) # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_math); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1168, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1168, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + } + } + __pyx_t_3 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_9, __pyx_v_var) : __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_var); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1168, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L6_except_return; + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "analysis.py":1165 + * + * var = variance(data, xbar) + * try: # <<<<<<<<<<<<<< + * return var.sqrt() + * except AttributeError: + */ + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + goto __pyx_L1_error; + __pyx_L7_try_return:; + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + goto __pyx_L0; + __pyx_L6_except_return:; + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + goto __pyx_L0; + } + + /* "analysis.py":1162 + * + * + * def stdev(data, xbar=None): # <<<<<<<<<<<<<< + * + * var = variance(data, xbar) + */ + + /* 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_5); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("analysis.stdev", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_var); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static struct __pyx_obj_8analysis___pyx_scope_struct___sum *__pyx_freelist_8analysis___pyx_scope_struct___sum[8]; +static int __pyx_freecount_8analysis___pyx_scope_struct___sum = 0; + +static PyObject *__pyx_tp_new_8analysis___pyx_scope_struct___sum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_8analysis___pyx_scope_struct___sum > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_8analysis___pyx_scope_struct___sum)))) { + o = (PyObject*)__pyx_freelist_8analysis___pyx_scope_struct___sum[--__pyx_freecount_8analysis___pyx_scope_struct___sum]; + memset(o, 0, sizeof(struct __pyx_obj_8analysis___pyx_scope_struct___sum)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_8analysis___pyx_scope_struct___sum(PyObject *o) { + struct __pyx_obj_8analysis___pyx_scope_struct___sum *p = (struct __pyx_obj_8analysis___pyx_scope_struct___sum *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_partials); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_8analysis___pyx_scope_struct___sum < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_8analysis___pyx_scope_struct___sum)))) { + __pyx_freelist_8analysis___pyx_scope_struct___sum[__pyx_freecount_8analysis___pyx_scope_struct___sum++] = ((struct __pyx_obj_8analysis___pyx_scope_struct___sum *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_8analysis___pyx_scope_struct___sum(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_8analysis___pyx_scope_struct___sum *p = (struct __pyx_obj_8analysis___pyx_scope_struct___sum *)o; + if (p->__pyx_v_partials) { + e = (*v)(p->__pyx_v_partials, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_8analysis___pyx_scope_struct___sum(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_8analysis___pyx_scope_struct___sum *p = (struct __pyx_obj_8analysis___pyx_scope_struct___sum *)o; + tmp = ((PyObject*)p->__pyx_v_partials); + p->__pyx_v_partials = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_8analysis___pyx_scope_struct___sum = { + PyVarObject_HEAD_INIT(0, 0) + "analysis.__pyx_scope_struct___sum", /*tp_name*/ + sizeof(struct __pyx_obj_8analysis___pyx_scope_struct___sum), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_8analysis___pyx_scope_struct___sum, /*tp_dealloc*/ + 0, /*tp_print*/ + 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_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_8analysis___pyx_scope_struct___sum, /*tp_traverse*/ + __pyx_tp_clear_8analysis___pyx_scope_struct___sum, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*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_8analysis___pyx_scope_struct___sum, /*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 +}; + +static struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr *__pyx_freelist_8analysis___pyx_scope_struct_1_genexpr[8]; +static int __pyx_freecount_8analysis___pyx_scope_struct_1_genexpr = 0; + +static PyObject *__pyx_tp_new_8analysis___pyx_scope_struct_1_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_8analysis___pyx_scope_struct_1_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr)))) { + o = (PyObject*)__pyx_freelist_8analysis___pyx_scope_struct_1_genexpr[--__pyx_freecount_8analysis___pyx_scope_struct_1_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_8analysis___pyx_scope_struct_1_genexpr(PyObject *o) { + struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_outer_scope); + Py_CLEAR(p->__pyx_v_d); + Py_CLEAR(p->__pyx_v_n); + Py_CLEAR(p->__pyx_t_0); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_8analysis___pyx_scope_struct_1_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr)))) { + __pyx_freelist_8analysis___pyx_scope_struct_1_genexpr[__pyx_freecount_8analysis___pyx_scope_struct_1_genexpr++] = ((struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_8analysis___pyx_scope_struct_1_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr *)o; + if (p->__pyx_outer_scope) { + e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e; + } + if (p->__pyx_v_d) { + e = (*v)(p->__pyx_v_d, a); if (e) return e; + } + if (p->__pyx_v_n) { + e = (*v)(p->__pyx_v_n, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} + +static PyTypeObject __pyx_type_8analysis___pyx_scope_struct_1_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "analysis.__pyx_scope_struct_1_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_1_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_8analysis___pyx_scope_struct_1_genexpr, /*tp_dealloc*/ + 0, /*tp_print*/ + 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_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_8analysis___pyx_scope_struct_1_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*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_8analysis___pyx_scope_struct_1_genexpr, /*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 +}; + +static struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg *__pyx_freelist_8analysis___pyx_scope_struct_2__fail_neg[8]; +static int __pyx_freecount_8analysis___pyx_scope_struct_2__fail_neg = 0; + +static PyObject *__pyx_tp_new_8analysis___pyx_scope_struct_2__fail_neg(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_8analysis___pyx_scope_struct_2__fail_neg > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg)))) { + o = (PyObject*)__pyx_freelist_8analysis___pyx_scope_struct_2__fail_neg[--__pyx_freecount_8analysis___pyx_scope_struct_2__fail_neg]; + memset(o, 0, sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_8analysis___pyx_scope_struct_2__fail_neg(PyObject *o) { + struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg *p = (struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_errmsg); + Py_CLEAR(p->__pyx_v_values); + Py_CLEAR(p->__pyx_v_x); + Py_CLEAR(p->__pyx_t_0); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_8analysis___pyx_scope_struct_2__fail_neg < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg)))) { + __pyx_freelist_8analysis___pyx_scope_struct_2__fail_neg[__pyx_freecount_8analysis___pyx_scope_struct_2__fail_neg++] = ((struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_8analysis___pyx_scope_struct_2__fail_neg(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg *p = (struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg *)o; + if (p->__pyx_v_errmsg) { + e = (*v)(p->__pyx_v_errmsg, a); if (e) return e; + } + if (p->__pyx_v_values) { + e = (*v)(p->__pyx_v_values, a); if (e) return e; + } + if (p->__pyx_v_x) { + e = (*v)(p->__pyx_v_x, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} + +static PyTypeObject __pyx_type_8analysis___pyx_scope_struct_2__fail_neg = { + PyVarObject_HEAD_INIT(0, 0) + "analysis.__pyx_scope_struct_2__fail_neg", /*tp_name*/ + sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_2__fail_neg), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_8analysis___pyx_scope_struct_2__fail_neg, /*tp_dealloc*/ + 0, /*tp_print*/ + 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_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_8analysis___pyx_scope_struct_2__fail_neg, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*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_8analysis___pyx_scope_struct_2__fail_neg, /*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 +}; + +static struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *__pyx_freelist_8analysis___pyx_scope_struct_3__ss[8]; +static int __pyx_freecount_8analysis___pyx_scope_struct_3__ss = 0; + +static PyObject *__pyx_tp_new_8analysis___pyx_scope_struct_3__ss(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_8analysis___pyx_scope_struct_3__ss > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_3__ss)))) { + o = (PyObject*)__pyx_freelist_8analysis___pyx_scope_struct_3__ss[--__pyx_freecount_8analysis___pyx_scope_struct_3__ss]; + memset(o, 0, sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_3__ss)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_8analysis___pyx_scope_struct_3__ss(PyObject *o) { + struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *p = (struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_c); + Py_CLEAR(p->__pyx_v_data); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_8analysis___pyx_scope_struct_3__ss < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_3__ss)))) { + __pyx_freelist_8analysis___pyx_scope_struct_3__ss[__pyx_freecount_8analysis___pyx_scope_struct_3__ss++] = ((struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_8analysis___pyx_scope_struct_3__ss(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *p = (struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *)o; + if (p->__pyx_v_c) { + e = (*v)(p->__pyx_v_c, a); if (e) return e; + } + if (p->__pyx_v_data) { + e = (*v)(p->__pyx_v_data, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_8analysis___pyx_scope_struct_3__ss(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *p = (struct __pyx_obj_8analysis___pyx_scope_struct_3__ss *)o; + tmp = ((PyObject*)p->__pyx_v_c); + p->__pyx_v_c = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_data); + p->__pyx_v_data = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_8analysis___pyx_scope_struct_3__ss = { + PyVarObject_HEAD_INIT(0, 0) + "analysis.__pyx_scope_struct_3__ss", /*tp_name*/ + sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_3__ss), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_8analysis___pyx_scope_struct_3__ss, /*tp_dealloc*/ + 0, /*tp_print*/ + 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_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_8analysis___pyx_scope_struct_3__ss, /*tp_traverse*/ + __pyx_tp_clear_8analysis___pyx_scope_struct_3__ss, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*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_8analysis___pyx_scope_struct_3__ss, /*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 +}; + +static struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr *__pyx_freelist_8analysis___pyx_scope_struct_4_genexpr[8]; +static int __pyx_freecount_8analysis___pyx_scope_struct_4_genexpr = 0; + +static PyObject *__pyx_tp_new_8analysis___pyx_scope_struct_4_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_8analysis___pyx_scope_struct_4_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr)))) { + o = (PyObject*)__pyx_freelist_8analysis___pyx_scope_struct_4_genexpr[--__pyx_freecount_8analysis___pyx_scope_struct_4_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_8analysis___pyx_scope_struct_4_genexpr(PyObject *o) { + struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr *p = (struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_outer_scope); + Py_CLEAR(p->__pyx_v_x); + Py_CLEAR(p->__pyx_t_0); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_8analysis___pyx_scope_struct_4_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr)))) { + __pyx_freelist_8analysis___pyx_scope_struct_4_genexpr[__pyx_freecount_8analysis___pyx_scope_struct_4_genexpr++] = ((struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_8analysis___pyx_scope_struct_4_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr *p = (struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr *)o; + if (p->__pyx_outer_scope) { + e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e; + } + if (p->__pyx_v_x) { + e = (*v)(p->__pyx_v_x, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} + +static PyTypeObject __pyx_type_8analysis___pyx_scope_struct_4_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "analysis.__pyx_scope_struct_4_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_4_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_8analysis___pyx_scope_struct_4_genexpr, /*tp_dealloc*/ + 0, /*tp_print*/ + 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_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_8analysis___pyx_scope_struct_4_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*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_8analysis___pyx_scope_struct_4_genexpr, /*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 +}; + +static struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr *__pyx_freelist_8analysis___pyx_scope_struct_5_genexpr[8]; +static int __pyx_freecount_8analysis___pyx_scope_struct_5_genexpr = 0; + +static PyObject *__pyx_tp_new_8analysis___pyx_scope_struct_5_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_8analysis___pyx_scope_struct_5_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr)))) { + o = (PyObject*)__pyx_freelist_8analysis___pyx_scope_struct_5_genexpr[--__pyx_freecount_8analysis___pyx_scope_struct_5_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_8analysis___pyx_scope_struct_5_genexpr(PyObject *o) { + struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr *p = (struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_outer_scope); + Py_CLEAR(p->__pyx_v_x); + Py_CLEAR(p->__pyx_t_0); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_8analysis___pyx_scope_struct_5_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr)))) { + __pyx_freelist_8analysis___pyx_scope_struct_5_genexpr[__pyx_freecount_8analysis___pyx_scope_struct_5_genexpr++] = ((struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_8analysis___pyx_scope_struct_5_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr *p = (struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr *)o; + if (p->__pyx_outer_scope) { + e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e; + } + if (p->__pyx_v_x) { + e = (*v)(p->__pyx_v_x, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} + +static PyTypeObject __pyx_type_8analysis___pyx_scope_struct_5_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "analysis.__pyx_scope_struct_5_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_8analysis___pyx_scope_struct_5_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_8analysis___pyx_scope_struct_5_genexpr, /*tp_dealloc*/ + 0, /*tp_print*/ + 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_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_8analysis___pyx_scope_struct_5_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*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_8analysis___pyx_scope_struct_5_genexpr, /*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 +}; + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +static int __pyx_import_star_set(PyObject *o, PyObject* py_name, char *name) { + static const char* internal_type_names[] = { + "__pyx_ctuple_Py_ssize_t", + "__pyx_ctuple_Py_ssize_t_struct", + "__pyx_ctuple_double", + "__pyx_ctuple_double_struct", + "__pyx_ctuple_long__and_Py_ssize_t", + "__pyx_ctuple_long__and_Py_ssize_t__and_long", + "__pyx_ctuple_long__and_Py_ssize_t__and_long_struct", + "__pyx_ctuple_long__and_Py_ssize_t_struct", + "__pyx_scope_struct_1_genexpr", + "__pyx_scope_struct_2__fail_neg", + "__pyx_scope_struct_3__ss", + "__pyx_scope_struct_4_genexpr", + "__pyx_scope_struct_5_genexpr", + "__pyx_scope_struct___sum", + 0 + }; + const char** type_name = internal_type_names; + while (*type_name) { + if (__Pyx_StrEq(name, *type_name)) { + PyErr_Format(PyExc_TypeError, "Cannot overwrite C type %s", name); + goto bad; + } + type_name++; + } + if (0); + else { + if (PyObject_SetAttr(__pyx_m, py_name, o) < 0) goto bad; + } + return 0; + bad: + return -1; +} + +static int +__Pyx_import_all_from(PyObject *locals, PyObject *v) +{ + PyObject *all = PyObject_GetAttrString(v, "__all__"); + PyObject *dict, *name, *value; + int skip_leading_underscores = 0; + int pos, err; + if (all == NULL) { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) + return -1; + PyErr_Clear(); + dict = PyObject_GetAttrString(v, "__dict__"); + if (dict == NULL) { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) + return -1; + PyErr_SetString(PyExc_ImportError, + "from-import-* object has no __dict__ and no __all__"); + return -1; + } +#if PY_MAJOR_VERSION < 3 + all = PyObject_CallMethod(dict, (char *)"keys", NULL); +#else + all = PyMapping_Keys(dict); +#endif + Py_DECREF(dict); + if (all == NULL) + return -1; + skip_leading_underscores = 1; + } + for (pos = 0, err = 0; ; pos++) { + name = PySequence_GetItem(all, pos); + if (name == NULL) { + if (!PyErr_ExceptionMatches(PyExc_IndexError)) + err = -1; + else + PyErr_Clear(); + break; + } + if (skip_leading_underscores && +#if PY_MAJOR_VERSION < 3 + PyString_Check(name) && + PyString_AS_STRING(name)[0] == '_') +#else + PyUnicode_Check(name) && + PyUnicode_AS_UNICODE(name)[0] == '_') +#endif + { + Py_DECREF(name); + continue; + } + value = PyObject_GetAttr(v, name); + if (value == NULL) + err = -1; + else if (PyDict_CheckExact(locals)) + err = PyDict_SetItem(locals, name, value); + else + err = PyObject_SetItem(locals, name, value); + Py_DECREF(name); + Py_XDECREF(value); + if (err != 0) + break; + } + Py_DECREF(all); + return err; +} +static int __pyx_import_star(PyObject* m) { + int i; + int ret = -1; + char* s; + PyObject *locals = 0; + PyObject *list = 0; +#if PY_MAJOR_VERSION >= 3 + PyObject *utf8_name = 0; +#endif + PyObject *name; + PyObject *item; + locals = PyDict_New(); if (!locals) goto bad; + if (__Pyx_import_all_from(locals, m) < 0) goto bad; + list = PyDict_Items(locals); if (!list) goto bad; + for(i=0; i= 3 + utf8_name = PyUnicode_AsUTF8String(name); + if (!utf8_name) goto bad; + s = PyBytes_AS_STRING(utf8_name); + if (__pyx_import_star_set(item, name, s) < 0) goto bad; + Py_DECREF(utf8_name); utf8_name = 0; +#else + s = PyString_AsString(name); + if (!s) goto bad; + if (__pyx_import_star_set(item, name, s) < 0) goto bad; +#endif + } + ret = 0; +bad: + Py_XDECREF(locals); + Py_XDECREF(list); +#if PY_MAJOR_VERSION >= 3 + Py_XDECREF(utf8_name); +#endif + return ret; +} + + + +#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_analysis(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_analysis}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "analysis", + 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 */ + NULL /* 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_kp_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 0}, + {&__pyx_kp_s_1_0_8_005, __pyx_k_1_0_8_005, sizeof(__pyx_k_1_0_8_005), 0, 0, 1, 0}, + {&__pyx_kp_s_1d, __pyx_k_1d, sizeof(__pyx_k_1d), 0, 0, 1, 0}, + {&__pyx_kp_s_Arthur_Lu_arthurlu_ttic_edu_Jaco, __pyx_k_Arthur_Lu_arthurlu_ttic_edu_Jaco, sizeof(__pyx_k_Arthur_Lu_arthurlu_ttic_edu_Jaco), 0, 0, 1, 0}, + {&__pyx_n_s_AttributeError, __pyx_k_AttributeError, sizeof(__pyx_k_AttributeError), 0, 0, 1, 1}, + {&__pyx_n_s_Counter, __pyx_k_Counter, sizeof(__pyx_k_Counter), 0, 0, 1, 1}, + {&__pyx_n_s_Decimal, __pyx_k_Decimal, sizeof(__pyx_k_Decimal), 0, 0, 1, 1}, + {&__pyx_n_s_Fraction, __pyx_k_Fraction, sizeof(__pyx_k_Fraction), 0, 0, 1, 1}, + {&__pyx_n_s_OverflowError, __pyx_k_OverflowError, sizeof(__pyx_k_OverflowError), 0, 0, 1, 1}, + {&__pyx_n_s_S, __pyx_k_S, sizeof(__pyx_k_S), 0, 0, 1, 1}, + {&__pyx_n_s_StatisticsError, __pyx_k_StatisticsError, sizeof(__pyx_k_StatisticsError), 0, 0, 1, 1}, + {&__pyx_n_s_T, __pyx_k_T, sizeof(__pyx_k_T), 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_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_kp_s__10, __pyx_k__10, sizeof(__pyx_k__10), 0, 0, 1, 0}, + {&__pyx_kp_s__13, __pyx_k__13, sizeof(__pyx_k__13), 0, 0, 1, 0}, + {&__pyx_kp_s__14, __pyx_k__14, sizeof(__pyx_k__14), 0, 0, 1, 0}, + {&__pyx_kp_s__15, __pyx_k__15, sizeof(__pyx_k__15), 0, 0, 1, 0}, + {&__pyx_n_s__17, __pyx_k__17, sizeof(__pyx_k__17), 0, 0, 1, 1}, + {&__pyx_kp_s__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 1, 0}, + {&__pyx_kp_s__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 0, 1, 0}, + {&__pyx_kp_s__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 0, 1, 0}, + {&__pyx_kp_s__7, __pyx_k__7, sizeof(__pyx_k__7), 0, 0, 1, 0}, + {&__pyx_kp_s__8, __pyx_k__8, sizeof(__pyx_k__8), 0, 0, 1, 0}, + {&__pyx_kp_s__9, __pyx_k__9, sizeof(__pyx_k__9), 0, 0, 1, 0}, + {&__pyx_n_s_a, __pyx_k_a, sizeof(__pyx_k_a), 0, 0, 1, 1}, + {&__pyx_n_s_adam, __pyx_k_adam, sizeof(__pyx_k_adam), 0, 0, 1, 1}, + {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, + {&__pyx_n_s_analysis, __pyx_k_analysis, sizeof(__pyx_k_analysis), 0, 0, 1, 1}, + {&__pyx_kp_s_analysis_py, __pyx_k_analysis_py, sizeof(__pyx_k_analysis_py), 0, 0, 1, 0}, + {&__pyx_n_s_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1}, + {&__pyx_n_s_arg, __pyx_k_arg, sizeof(__pyx_k_arg), 0, 0, 1, 1}, + {&__pyx_n_s_argmax, __pyx_k_argmax, sizeof(__pyx_k_argmax), 0, 0, 1, 1}, + {&__pyx_n_s_argmin, __pyx_k_argmin, sizeof(__pyx_k_argmin), 0, 0, 1, 1}, + {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, + {&__pyx_n_s_array, __pyx_k_array, sizeof(__pyx_k_array), 0, 0, 1, 1}, + {&__pyx_n_s_as_integer_ratio, __pyx_k_as_integer_ratio, sizeof(__pyx_k_as_integer_ratio), 0, 0, 1, 1}, + {&__pyx_n_s_author, __pyx_k_author, sizeof(__pyx_k_author), 0, 0, 1, 1}, + {&__pyx_n_s_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1}, + {&__pyx_n_s_b_eq, __pyx_k_b_eq, sizeof(__pyx_k_b_eq), 0, 0, 1, 1}, + {&__pyx_n_s_b_overfit, __pyx_k_b_overfit, sizeof(__pyx_k_b_overfit), 0, 0, 1, 1}, + {&__pyx_n_s_b_r2, __pyx_k_b_r2, sizeof(__pyx_k_b_r2), 0, 0, 1, 1}, + {&__pyx_n_s_b_rms, __pyx_k_b_rms, sizeof(__pyx_k_b_rms), 0, 0, 1, 1}, + {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1}, + {&__pyx_n_s_basic_analysis, __pyx_k_basic_analysis, sizeof(__pyx_k_basic_analysis), 0, 0, 1, 1}, + {&__pyx_n_s_basic_stats, __pyx_k_basic_stats, sizeof(__pyx_k_basic_stats), 0, 0, 1, 1}, + {&__pyx_kp_s_basic_stats_requires_3_args_data, __pyx_k_basic_stats_requires_3_args_data, sizeof(__pyx_k_basic_stats_requires_3_args_data), 0, 0, 1, 0}, + {&__pyx_n_s_benchmark, __pyx_k_benchmark, sizeof(__pyx_k_benchmark), 0, 0, 1, 1}, + {&__pyx_n_s_bisect, __pyx_k_bisect, sizeof(__pyx_k_bisect), 0, 0, 1, 1}, + {&__pyx_n_s_bisect_left, __pyx_k_bisect_left, sizeof(__pyx_k_bisect_left), 0, 0, 1, 1}, + {&__pyx_n_s_bisect_right, __pyx_k_bisect_right, sizeof(__pyx_k_bisect_right), 0, 0, 1, 1}, + {&__pyx_n_s_both, __pyx_k_both, sizeof(__pyx_k_both), 0, 0, 1, 1}, + {&__pyx_n_s_builtins, __pyx_k_builtins, sizeof(__pyx_k_builtins), 0, 0, 1, 1}, + {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1}, + {&__pyx_n_s_c_data, __pyx_k_c_data, sizeof(__pyx_k_c_data), 0, 0, 1, 1}, + {&__pyx_n_s_c_data_sorted, __pyx_k_c_data_sorted, sizeof(__pyx_k_c_data_sorted), 0, 0, 1, 1}, + {&__pyx_n_s_c_effects, __pyx_k_c_effects, sizeof(__pyx_k_c_effects), 0, 0, 1, 1}, + {&__pyx_n_s_c_entities, __pyx_k_c_entities, sizeof(__pyx_k_c_entities), 0, 0, 1, 1}, + {&__pyx_n_s_c_entities___init, __pyx_k_c_entities___init, sizeof(__pyx_k_c_entities___init), 0, 0, 1, 1}, + {&__pyx_n_s_c_entities_append, __pyx_k_c_entities_append, sizeof(__pyx_k_c_entities_append), 0, 0, 1, 1}, + {&__pyx_n_s_c_entities_debug, __pyx_k_c_entities_debug, sizeof(__pyx_k_c_entities_debug), 0, 0, 1, 1}, + {&__pyx_n_s_c_entities_edit, __pyx_k_c_entities_edit, sizeof(__pyx_k_c_entities_edit), 0, 0, 1, 1}, + {&__pyx_kp_s_c_entities_has_attributes_names, __pyx_k_c_entities_has_attributes_names, sizeof(__pyx_k_c_entities_has_attributes_names), 0, 0, 1, 0}, + {&__pyx_n_s_c_entities_regurgitate, __pyx_k_c_entities_regurgitate, sizeof(__pyx_k_c_entities_regurgitate), 0, 0, 1, 1}, + {&__pyx_n_s_c_entities_search, __pyx_k_c_entities_search, sizeof(__pyx_k_c_entities_search), 0, 0, 1, 1}, + {&__pyx_n_s_c_ids, __pyx_k_c_ids, sizeof(__pyx_k_c_ids), 0, 0, 1, 1}, + {&__pyx_n_s_c_logic, __pyx_k_c_logic, sizeof(__pyx_k_c_logic), 0, 0, 1, 1}, + {&__pyx_n_s_c_names, __pyx_k_c_names, sizeof(__pyx_k_c_names), 0, 0, 1, 1}, + {&__pyx_n_s_c_perim, __pyx_k_c_perim, sizeof(__pyx_k_c_perim), 0, 0, 1, 1}, + {&__pyx_n_s_c_pos, __pyx_k_c_pos, sizeof(__pyx_k_c_pos), 0, 0, 1, 1}, + {&__pyx_n_s_c_properties, __pyx_k_c_properties, sizeof(__pyx_k_c_properties), 0, 0, 1, 1}, + {&__pyx_n_s_calc_overfit, __pyx_k_calc_overfit, sizeof(__pyx_k_calc_overfit), 0, 0, 1, 1}, + {&__pyx_kp_s_can_t_convert_type_to_numerator, __pyx_k_can_t_convert_type_to_numerator, sizeof(__pyx_k_can_t_convert_type_to_numerator), 0, 0, 1, 0}, + {&__pyx_n_s_changelog, __pyx_k_changelog, sizeof(__pyx_k_changelog), 0, 0, 1, 1}, + {&__pyx_kp_s_changelog_1_0_8_005_minor_fixes, __pyx_k_changelog_1_0_8_005_minor_fixes, sizeof(__pyx_k_changelog_1_0_8_005_minor_fixes), 0, 0, 1, 0}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, + {&__pyx_n_s_coerce, __pyx_k_coerce, sizeof(__pyx_k_coerce), 0, 0, 1, 1}, + {&__pyx_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1}, + {&__pyx_n_s_column, __pyx_k_column, sizeof(__pyx_k_column), 0, 0, 1, 1}, + {&__pyx_n_s_column_b_stats, __pyx_k_column_b_stats, sizeof(__pyx_k_column_b_stats), 0, 0, 1, 1}, + {&__pyx_n_s_column_max, __pyx_k_column_max, sizeof(__pyx_k_column_max), 0, 0, 1, 1}, + {&__pyx_n_s_convert, __pyx_k_convert, sizeof(__pyx_k_convert), 0, 0, 1, 1}, + {&__pyx_kp_s_could_not_assign_cpu, __pyx_k_could_not_assign_cpu, sizeof(__pyx_k_could_not_assign_cpu), 0, 0, 1, 0}, + {&__pyx_kp_s_could_not_assign_cuda_or_cpu, __pyx_k_could_not_assign_cuda_or_cpu, sizeof(__pyx_k_could_not_assign_cuda_or_cpu), 0, 0, 1, 0}, + {&__pyx_n_s_count, __pyx_k_count, sizeof(__pyx_k_count), 0, 0, 1, 1}, + {&__pyx_n_s_count2, __pyx_k_count2, sizeof(__pyx_k_count2), 0, 0, 1, 1}, + {&__pyx_n_s_counts, __pyx_k_counts, sizeof(__pyx_k_counts), 0, 0, 1, 1}, + {&__pyx_n_s_cpu, __pyx_k_cpu, sizeof(__pyx_k_cpu), 0, 0, 1, 1}, + {&__pyx_n_s_csv, __pyx_k_csv, sizeof(__pyx_k_csv), 0, 0, 1, 1}, + {&__pyx_n_s_csvfile, __pyx_k_csvfile, sizeof(__pyx_k_csvfile), 0, 0, 1, 1}, + {&__pyx_n_s_cuda, __pyx_k_cuda, sizeof(__pyx_k_cuda), 0, 0, 1, 1}, + {&__pyx_n_s_curve_fit, __pyx_k_curve_fit, sizeof(__pyx_k_curve_fit), 0, 0, 1, 1}, + {&__pyx_n_s_d, __pyx_k_d, sizeof(__pyx_k_d), 0, 0, 1, 1}, + {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1}, + {&__pyx_kp_s_data_data_csv, __pyx_k_data_data_csv, sizeof(__pyx_k_data_data_csv), 0, 0, 1, 0}, + {&__pyx_n_s_data_t, __pyx_k_data_t, sizeof(__pyx_k_data_t), 0, 0, 1, 1}, + {&__pyx_n_s_debug, __pyx_k_debug, sizeof(__pyx_k_debug), 0, 0, 1, 1}, + {&__pyx_n_s_decimal, __pyx_k_decimal, sizeof(__pyx_k_decimal), 0, 0, 1, 1}, + {&__pyx_n_s_deg, __pyx_k_deg, sizeof(__pyx_k_deg), 0, 0, 1, 1}, + {&__pyx_n_s_delta, __pyx_k_delta, sizeof(__pyx_k_delta), 0, 0, 1, 1}, + {&__pyx_n_s_denominator, __pyx_k_denominator, sizeof(__pyx_k_denominator), 0, 0, 1, 1}, + {&__pyx_n_s_derivative, __pyx_k_derivative, sizeof(__pyx_k_derivative), 0, 0, 1, 1}, + {&__pyx_n_s_derivative_sorted, __pyx_k_derivative_sorted, sizeof(__pyx_k_derivative_sorted), 0, 0, 1, 1}, + {&__pyx_n_s_device, __pyx_k_device, sizeof(__pyx_k_device), 0, 0, 1, 1}, + {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, + {&__pyx_kp_s_don_t_know_how_to_coerce_s_and_s, __pyx_k_don_t_know_how_to_coerce_s_and_s, sizeof(__pyx_k_don_t_know_how_to_coerce_s_and_s), 0, 0, 1, 0}, + {&__pyx_n_s_e, __pyx_k_e, sizeof(__pyx_k_e), 0, 0, 1, 1}, + {&__pyx_n_s_edit, __pyx_k_edit, sizeof(__pyx_k_edit), 0, 0, 1, 1}, + {&__pyx_n_s_effects, __pyx_k_effects, sizeof(__pyx_k_effects), 0, 0, 1, 1}, + {&__pyx_n_s_end, __pyx_k_end, sizeof(__pyx_k_end), 0, 0, 1, 1}, + {&__pyx_n_s_end_a, __pyx_k_end_a, sizeof(__pyx_k_end_a), 0, 0, 1, 1}, + {&__pyx_n_s_end_g, __pyx_k_end_g, sizeof(__pyx_k_end_g), 0, 0, 1, 1}, + {&__pyx_n_s_enter, __pyx_k_enter, sizeof(__pyx_k_enter), 0, 0, 1, 1}, + {&__pyx_n_s_eq_str, __pyx_k_eq_str, sizeof(__pyx_k_eq_str), 0, 0, 1, 1}, + {&__pyx_n_s_eqs, __pyx_k_eqs, sizeof(__pyx_k_eqs), 0, 0, 1, 1}, + {&__pyx_n_s_equation, __pyx_k_equation, sizeof(__pyx_k_equation), 0, 0, 1, 1}, + {&__pyx_n_s_errmsg, __pyx_k_errmsg, sizeof(__pyx_k_errmsg), 0, 0, 1, 1}, + {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, + {&__pyx_n_s_eve, __pyx_k_eve, sizeof(__pyx_k_eve), 0, 0, 1, 1}, + {&__pyx_n_s_exact_ratio, __pyx_k_exact_ratio, sizeof(__pyx_k_exact_ratio), 0, 0, 1, 1}, + {&__pyx_n_s_exit, __pyx_k_exit, sizeof(__pyx_k_exit), 0, 0, 1, 1}, + {&__pyx_n_s_exp_regression, __pyx_k_exp_regression, sizeof(__pyx_k_exp_regression), 0, 0, 1, 1}, + {&__pyx_n_s_fail_neg, __pyx_k_fail_neg, sizeof(__pyx_k_fail_neg), 0, 0, 1, 1}, + {&__pyx_n_s_file, __pyx_k_file, sizeof(__pyx_k_file), 0, 0, 1, 1}, + {&__pyx_n_s_file_array, __pyx_k_file_array, sizeof(__pyx_k_file_array), 0, 0, 1, 1}, + {&__pyx_n_s_filename, __pyx_k_filename, sizeof(__pyx_k_filename), 0, 0, 1, 1}, + {&__pyx_n_s_filepath, __pyx_k_filepath, sizeof(__pyx_k_filepath), 0, 0, 1, 1}, + {&__pyx_n_s_find_lteq, __pyx_k_find_lteq, sizeof(__pyx_k_find_lteq), 0, 0, 1, 1}, + {&__pyx_n_s_find_rteq, __pyx_k_find_rteq, sizeof(__pyx_k_find_rteq), 0, 0, 1, 1}, + {&__pyx_n_s_float64, __pyx_k_float64, sizeof(__pyx_k_float64), 0, 0, 1, 1}, + {&__pyx_n_s_floor, __pyx_k_floor, sizeof(__pyx_k_floor), 0, 0, 1, 1}, + {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, + {&__pyx_n_s_fractions, __pyx_k_fractions, sizeof(__pyx_k_fractions), 0, 0, 1, 1}, + {&__pyx_n_s_functools, __pyx_k_functools, sizeof(__pyx_k_functools), 0, 0, 1, 1}, + {&__pyx_n_s_generate_data, __pyx_k_generate_data, sizeof(__pyx_k_generate_data), 0, 0, 1, 1}, + {&__pyx_n_s_genexpr, __pyx_k_genexpr, sizeof(__pyx_k_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, + {&__pyx_n_s_groupby, __pyx_k_groupby, sizeof(__pyx_k_groupby), 0, 0, 1, 1}, + {&__pyx_n_s_high, __pyx_k_high, sizeof(__pyx_k_high), 0, 0, 1, 1}, + {&__pyx_n_s_high_bound, __pyx_k_high_bound, sizeof(__pyx_k_high_bound), 0, 0, 1, 1}, + {&__pyx_n_s_hist_data, __pyx_k_hist_data, sizeof(__pyx_k_hist_data), 0, 0, 1, 1}, + {&__pyx_n_s_histo_analysis, __pyx_k_histo_analysis, sizeof(__pyx_k_histo_analysis), 0, 0, 1, 1}, + {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, + {&__pyx_n_s_ids, __pyx_k_ids, sizeof(__pyx_k_ids), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_ind, __pyx_k_ind, sizeof(__pyx_k_ind), 0, 0, 1, 1}, + {&__pyx_n_s_index, __pyx_k_index, sizeof(__pyx_k_index), 0, 0, 1, 1}, + {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, + {&__pyx_n_s_init_device, __pyx_k_init_device, sizeof(__pyx_k_init_device), 0, 0, 1, 1}, + {&__pyx_kp_s_initial_type_T_is_bool, __pyx_k_initial_type_T_is_bool, sizeof(__pyx_k_initial_type_T_is_bool), 0, 0, 1, 0}, + {&__pyx_n_s_is_available, __pyx_k_is_available, sizeof(__pyx_k_is_available), 0, 0, 1, 1}, + {&__pyx_n_s_is_finite, __pyx_k_is_finite, sizeof(__pyx_k_is_finite), 0, 0, 1, 1}, + {&__pyx_n_s_isfinite, __pyx_k_isfinite, sizeof(__pyx_k_isfinite), 0, 0, 1, 1}, + {&__pyx_n_s_isfinite_2, __pyx_k_isfinite_2, sizeof(__pyx_k_isfinite_2), 0, 0, 1, 1}, + {&__pyx_n_s_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1}, + {&__pyx_n_s_itertools, __pyx_k_itertools, sizeof(__pyx_k_itertools), 0, 0, 1, 1}, + {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, + {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1}, + {&__pyx_n_s_l, __pyx_k_l, sizeof(__pyx_k_l), 0, 0, 1, 1}, + {&__pyx_n_s_lo, __pyx_k_lo, sizeof(__pyx_k_lo), 0, 0, 1, 1}, + {&__pyx_n_s_load_csv, __pyx_k_load_csv, sizeof(__pyx_k_load_csv), 0, 0, 1, 1}, + {&__pyx_n_s_log, __pyx_k_log, sizeof(__pyx_k_log), 0, 0, 1, 1}, + {&__pyx_n_s_log_regression, __pyx_k_log_regression, sizeof(__pyx_k_log_regression), 0, 0, 1, 1}, + {&__pyx_n_s_logic, __pyx_k_logic, sizeof(__pyx_k_logic), 0, 0, 1, 1}, + {&__pyx_n_s_low, __pyx_k_low, sizeof(__pyx_k_low), 0, 0, 1, 1}, + {&__pyx_n_s_low_bound, __pyx_k_low_bound, sizeof(__pyx_k_low_bound), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_map, __pyx_k_map, sizeof(__pyx_k_map), 0, 0, 1, 1}, + {&__pyx_n_s_math, __pyx_k_math, sizeof(__pyx_k_math), 0, 0, 1, 1}, + {&__pyx_n_s_matplotlib, __pyx_k_matplotlib, sizeof(__pyx_k_matplotlib), 0, 0, 1, 1}, + {&__pyx_n_s_max, __pyx_k_max, sizeof(__pyx_k_max), 0, 0, 1, 1}, + {&__pyx_n_s_max_r2s, __pyx_k_max_r2s, sizeof(__pyx_k_max_r2s), 0, 0, 1, 1}, + {&__pyx_n_s_maxfreq, __pyx_k_maxfreq, sizeof(__pyx_k_maxfreq), 0, 0, 1, 1}, + {&__pyx_n_s_mean, __pyx_k_mean, sizeof(__pyx_k_mean), 0, 0, 1, 1}, + {&__pyx_n_s_mean_2, __pyx_k_mean_2, sizeof(__pyx_k_mean_2), 0, 0, 1, 1}, + {&__pyx_n_s_mean_derivative, __pyx_k_mean_derivative, sizeof(__pyx_k_mean_derivative), 0, 0, 1, 1}, + {&__pyx_kp_s_mean_requires_at_least_one_data, __pyx_k_mean_requires_at_least_one_data, sizeof(__pyx_k_mean_requires_at_least_one_data), 0, 0, 1, 0}, + {&__pyx_n_s_median, __pyx_k_median, sizeof(__pyx_k_median), 0, 0, 1, 1}, + {&__pyx_n_s_median_2, __pyx_k_median_2, sizeof(__pyx_k_median_2), 0, 0, 1, 1}, + {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, + {&__pyx_n_s_method, __pyx_k_method, sizeof(__pyx_k_method), 0, 0, 1, 1}, + {&__pyx_kp_s_method_error, __pyx_k_method_error, sizeof(__pyx_k_method_error), 0, 0, 1, 0}, + {&__pyx_n_s_metrics, __pyx_k_metrics, sizeof(__pyx_k_metrics), 0, 0, 1, 1}, + {&__pyx_n_s_min_overfit, __pyx_k_min_overfit, sizeof(__pyx_k_min_overfit), 0, 0, 1, 1}, + {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1}, + {&__pyx_n_s_mode_2, __pyx_k_mode_2, sizeof(__pyx_k_mode_2), 0, 0, 1, 1}, + {&__pyx_kp_s_mode_error, __pyx_k_mode_error, sizeof(__pyx_k_mode_error), 0, 0, 1, 0}, + {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, + {&__pyx_n_s_most_common, __pyx_k_most_common, sizeof(__pyx_k_most_common), 0, 0, 1, 1}, + {&__pyx_n_s_msg, __pyx_k_msg, sizeof(__pyx_k_msg), 0, 0, 1, 1}, + {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, + {&__pyx_n_s_n_effect, __pyx_k_n_effect, sizeof(__pyx_k_n_effect), 0, 0, 1, 1}, + {&__pyx_n_s_n_id, __pyx_k_n_id, sizeof(__pyx_k_n_id), 0, 0, 1, 1}, + {&__pyx_n_s_n_logic, __pyx_k_n_logic, sizeof(__pyx_k_n_logic), 0, 0, 1, 1}, + {&__pyx_n_s_n_name, __pyx_k_n_name, sizeof(__pyx_k_n_name), 0, 0, 1, 1}, + {&__pyx_n_s_n_perim, __pyx_k_n_perim, sizeof(__pyx_k_n_perim), 0, 0, 1, 1}, + {&__pyx_n_s_n_pos, __pyx_k_n_pos, sizeof(__pyx_k_n_pos), 0, 0, 1, 1}, + {&__pyx_n_s_n_property, __pyx_k_n_property, sizeof(__pyx_k_n_property), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_names, __pyx_k_names, sizeof(__pyx_k_names), 0, 0, 1, 1}, + {&__pyx_n_s_nc_entities, __pyx_k_nc_entities, sizeof(__pyx_k_nc_entities), 0, 0, 1, 1}, + {&__pyx_n_s_nc_entities___init, __pyx_k_nc_entities___init, sizeof(__pyx_k_nc_entities___init), 0, 0, 1, 1}, + {&__pyx_n_s_nc_entities_append, __pyx_k_nc_entities_append, sizeof(__pyx_k_nc_entities_append), 0, 0, 1, 1}, + {&__pyx_n_s_nc_entities_debug, __pyx_k_nc_entities_debug, sizeof(__pyx_k_nc_entities_debug), 0, 0, 1, 1}, + {&__pyx_n_s_nc_entities_edit, __pyx_k_nc_entities_edit, sizeof(__pyx_k_nc_entities_edit), 0, 0, 1, 1}, + {&__pyx_kp_s_nc_entities_non_controlable_enti, __pyx_k_nc_entities_non_controlable_enti, sizeof(__pyx_k_nc_entities_non_controlable_enti), 0, 0, 1, 0}, + {&__pyx_n_s_nc_entities_regurgitate, __pyx_k_nc_entities_regurgitate, sizeof(__pyx_k_nc_entities_regurgitate), 0, 0, 1, 1}, + {&__pyx_n_s_nc_entities_search, __pyx_k_nc_entities_search, sizeof(__pyx_k_nc_entities_search), 0, 0, 1, 1}, + {&__pyx_kp_s_negative_sum_of_square_deviation, __pyx_k_negative_sum_of_square_deviation, sizeof(__pyx_k_negative_sum_of_square_deviation), 0, 0, 1, 0}, + {&__pyx_kp_s_negative_value, __pyx_k_negative_value, sizeof(__pyx_k_negative_value), 0, 0, 1, 0}, + {&__pyx_n_s_newline, __pyx_k_newline, sizeof(__pyx_k_newline), 0, 0, 1, 1}, + {&__pyx_kp_s_no_median_for_empty_data, __pyx_k_no_median_for_empty_data, sizeof(__pyx_k_no_median_for_empty_data), 0, 0, 1, 0}, + {&__pyx_kp_s_no_mode_for_empty_data, __pyx_k_no_mode_for_empty_data, sizeof(__pyx_k_no_mode_for_empty_data), 0, 0, 1, 0}, + {&__pyx_kp_s_no_unique_mode_found_d_equally_c, __pyx_k_no_unique_mode_found_d_equally_c, sizeof(__pyx_k_no_unique_mode_found_d_equally_c), 0, 0, 1, 0}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_kp_s_np_log_z_np_log, __pyx_k_np_log_z_np_log, sizeof(__pyx_k_np_log_z_np_log), 0, 0, 1, 0}, + {&__pyx_kp_s_np_tanh, __pyx_k_np_tanh, sizeof(__pyx_k_np_tanh), 0, 0, 1, 0}, + {&__pyx_n_s_null, __pyx_k_null, sizeof(__pyx_k_null), 0, 0, 1, 1}, + {&__pyx_n_s_numbers, __pyx_k_numbers, sizeof(__pyx_k_numbers), 0, 0, 1, 1}, + {&__pyx_n_s_numerator, __pyx_k_numerator, sizeof(__pyx_k_numerator), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_n_s_objectives, __pyx_k_objectives, sizeof(__pyx_k_objectives), 0, 0, 1, 1}, + {&__pyx_n_s_objectives___init, __pyx_k_objectives___init, sizeof(__pyx_k_objectives___init), 0, 0, 1, 1}, + {&__pyx_n_s_objectives_append, __pyx_k_objectives_append, sizeof(__pyx_k_objectives_append), 0, 0, 1, 1}, + {&__pyx_n_s_objectives_debug, __pyx_k_objectives_debug, sizeof(__pyx_k_objectives_debug), 0, 0, 1, 1}, + {&__pyx_n_s_objectives_edit, __pyx_k_objectives_edit, sizeof(__pyx_k_objectives_edit), 0, 0, 1, 1}, + {&__pyx_kp_s_objectives_has_atributes_names_i, __pyx_k_objectives_has_atributes_names_i, sizeof(__pyx_k_objectives_has_atributes_names_i), 0, 0, 1, 0}, + {&__pyx_n_s_objectives_regurgitate, __pyx_k_objectives_regurgitate, sizeof(__pyx_k_objectives_regurgitate), 0, 0, 1, 1}, + {&__pyx_n_s_objectives_search, __pyx_k_objectives_search, sizeof(__pyx_k_objectives_search), 0, 0, 1, 1}, + {&__pyx_n_s_obstacles, __pyx_k_obstacles, sizeof(__pyx_k_obstacles), 0, 0, 1, 1}, + {&__pyx_n_s_obstacles___init, __pyx_k_obstacles___init, sizeof(__pyx_k_obstacles___init), 0, 0, 1, 1}, + {&__pyx_n_s_obstacles_append, __pyx_k_obstacles_append, sizeof(__pyx_k_obstacles_append), 0, 0, 1, 1}, + {&__pyx_n_s_obstacles_debug, __pyx_k_obstacles_debug, sizeof(__pyx_k_obstacles_debug), 0, 0, 1, 1}, + {&__pyx_n_s_obstacles_edit, __pyx_k_obstacles_edit, sizeof(__pyx_k_obstacles_edit), 0, 0, 1, 1}, + {&__pyx_kp_s_obstacles_has_atributes_names_id, __pyx_k_obstacles_has_atributes_names_id, sizeof(__pyx_k_obstacles_has_atributes_names_id), 0, 0, 1, 0}, + {&__pyx_n_s_obstacles_regurgitate, __pyx_k_obstacles_regurgitate, sizeof(__pyx_k_obstacles_regurgitate), 0, 0, 1, 1}, + {&__pyx_n_s_obstacles_search, __pyx_k_obstacles_search, sizeof(__pyx_k_obstacles_search), 0, 0, 1, 1}, + {&__pyx_n_s_open, __pyx_k_open, sizeof(__pyx_k_open), 0, 0, 1, 1}, + {&__pyx_n_s_optimize_regression, __pyx_k_optimize_regression, sizeof(__pyx_k_optimize_regression), 0, 0, 1, 1}, + {&__pyx_n_s_overfit, __pyx_k_overfit, sizeof(__pyx_k_overfit), 0, 0, 1, 1}, + {&__pyx_n_s_p_value, __pyx_k_p_value, sizeof(__pyx_k_p_value), 0, 0, 1, 1}, + {&__pyx_n_s_pandas, __pyx_k_pandas, sizeof(__pyx_k_pandas), 0, 0, 1, 1}, + {&__pyx_n_s_partials, __pyx_k_partials, sizeof(__pyx_k_partials), 0, 0, 1, 1}, + {&__pyx_n_s_partials_get, __pyx_k_partials_get, sizeof(__pyx_k_partials_get), 0, 0, 1, 1}, + {&__pyx_n_s_perims, __pyx_k_perims, sizeof(__pyx_k_perims), 0, 0, 1, 1}, + {&__pyx_n_s_pi, __pyx_k_pi, sizeof(__pyx_k_pi), 0, 0, 1, 1}, + {&__pyx_n_s_point, __pyx_k_point, sizeof(__pyx_k_point), 0, 0, 1, 1}, + {&__pyx_n_s_poly_regression, __pyx_k_poly_regression, sizeof(__pyx_k_poly_regression), 0, 0, 1, 1}, + {&__pyx_n_s_polyfit, __pyx_k_polyfit, sizeof(__pyx_k_polyfit), 0, 0, 1, 1}, + {&__pyx_n_s_pop, __pyx_k_pop, sizeof(__pyx_k_pop), 0, 0, 1, 1}, + {&__pyx_n_s_pos, __pyx_k_pos, sizeof(__pyx_k_pos), 0, 0, 1, 1}, + {&__pyx_n_s_position, __pyx_k_position, sizeof(__pyx_k_position), 0, 0, 1, 1}, + {&__pyx_n_s_power, __pyx_k_power, sizeof(__pyx_k_power), 0, 0, 1, 1}, + {&__pyx_n_s_pred_change, __pyx_k_pred_change, sizeof(__pyx_k_pred_change), 0, 0, 1, 1}, + {&__pyx_n_s_predictions, __pyx_k_predictions, sizeof(__pyx_k_predictions), 0, 0, 1, 1}, + {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, + {&__pyx_n_s_print, __pyx_k_print, sizeof(__pyx_k_print), 0, 0, 1, 1}, + {&__pyx_n_s_properties, __pyx_k_properties, sizeof(__pyx_k_properties), 0, 0, 1, 1}, + {&__pyx_n_s_q_str, __pyx_k_q_str, sizeof(__pyx_k_q_str), 0, 0, 1, 1}, + {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, + {&__pyx_n_s_r2_d2, __pyx_k_r2_d2, sizeof(__pyx_k_r2_d2), 0, 0, 1, 1}, + {&__pyx_n_s_r2_score, __pyx_k_r2_score, sizeof(__pyx_k_r2_score), 0, 0, 1, 1}, + {&__pyx_n_s_r2_test, __pyx_k_r2_test, sizeof(__pyx_k_r2_test), 0, 0, 1, 1}, + {&__pyx_n_s_r2_train, __pyx_k_r2_train, sizeof(__pyx_k_r2_train), 0, 0, 1, 1}, + {&__pyx_n_s_r2s, __pyx_k_r2s, sizeof(__pyx_k_r2s), 0, 0, 1, 1}, + {&__pyx_n_s_r_data, __pyx_k_r_data, sizeof(__pyx_k_r_data), 0, 0, 1, 1}, + {&__pyx_n_s_r_squared, __pyx_k_r_squared, sizeof(__pyx_k_r_squared), 0, 0, 1, 1}, + {&__pyx_n_s_randint, __pyx_k_randint, sizeof(__pyx_k_randint), 0, 0, 1, 1}, + {&__pyx_n_s_random, __pyx_k_random, sizeof(__pyx_k_random), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_range_2, __pyx_k_range_2, sizeof(__pyx_k_range_2), 0, 0, 1, 1}, + {&__pyx_n_s_reader, __pyx_k_reader, sizeof(__pyx_k_reader), 0, 0, 1, 1}, + {&__pyx_n_s_reg_eq, __pyx_k_reg_eq, sizeof(__pyx_k_reg_eq), 0, 0, 1, 1}, + {&__pyx_n_s_regurgitate, __pyx_k_regurgitate, sizeof(__pyx_k_regurgitate), 0, 0, 1, 1}, + {&__pyx_n_s_remove, __pyx_k_remove, sizeof(__pyx_k_remove), 0, 0, 1, 1}, + {&__pyx_n_s_resolution, __pyx_k_resolution, sizeof(__pyx_k_resolution), 0, 0, 1, 1}, + {&__pyx_kp_s_resolution_must_be_int, __pyx_k_resolution_must_be_int, sizeof(__pyx_k_resolution_must_be_int), 0, 0, 1, 0}, + {&__pyx_kp_s_returns_list_of_predicted_values, __pyx_k_returns_list_of_predicted_values, sizeof(__pyx_k_returns_list_of_predicted_values), 0, 0, 1, 0}, + {&__pyx_n_s_rms, __pyx_k_rms, sizeof(__pyx_k_rms), 0, 0, 1, 1}, + {&__pyx_n_s_rms_2, __pyx_k_rms_2, sizeof(__pyx_k_rms_2), 0, 0, 1, 1}, + {&__pyx_n_s_rms_test, __pyx_k_rms_test, sizeof(__pyx_k_rms_test), 0, 0, 1, 1}, + {&__pyx_n_s_rms_train, __pyx_k_rms_train, sizeof(__pyx_k_rms_train), 0, 0, 1, 1}, + {&__pyx_n_s_rmss, __pyx_k_rmss, sizeof(__pyx_k_rmss), 0, 0, 1, 1}, + {&__pyx_n_s_row, __pyx_k_row, sizeof(__pyx_k_row), 0, 0, 1, 1}, + {&__pyx_n_s_row_b_stats, __pyx_k_row_b_stats, sizeof(__pyx_k_row_b_stats), 0, 0, 1, 1}, + {&__pyx_n_s_row_histo, __pyx_k_row_histo, sizeof(__pyx_k_row_histo), 0, 0, 1, 1}, + {&__pyx_n_s_scipy, __pyx_k_scipy, sizeof(__pyx_k_scipy), 0, 0, 1, 1}, + {&__pyx_n_s_scipy_optimize, __pyx_k_scipy_optimize, sizeof(__pyx_k_scipy_optimize), 0, 0, 1, 1}, + {&__pyx_n_s_score, __pyx_k_score, sizeof(__pyx_k_score), 0, 0, 1, 1}, + {&__pyx_n_s_search, __pyx_k_search, sizeof(__pyx_k_search), 0, 0, 1, 1}, + {&__pyx_n_s_select_best_regression, __pyx_k_select_best_regression, sizeof(__pyx_k_select_best_regression), 0, 0, 1, 1}, + {&__pyx_n_s_selector, __pyx_k_selector, sizeof(__pyx_k_selector), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1}, + {&__pyx_n_s_setting, __pyx_k_setting, sizeof(__pyx_k_setting), 0, 0, 1, 1}, + {&__pyx_n_s_sklearn, __pyx_k_sklearn, sizeof(__pyx_k_sklearn), 0, 0, 1, 1}, + {&__pyx_n_s_sorted, __pyx_k_sorted, sizeof(__pyx_k_sorted), 0, 0, 1, 1}, + {&__pyx_kp_s_specified_device_does_not_exist, __pyx_k_specified_device_does_not_exist, sizeof(__pyx_k_specified_device_does_not_exist), 0, 0, 1, 0}, + {&__pyx_n_s_sqrt, __pyx_k_sqrt, sizeof(__pyx_k_sqrt), 0, 0, 1, 1}, + {&__pyx_n_s_ss, __pyx_k_ss, sizeof(__pyx_k_ss), 0, 0, 1, 1}, + {&__pyx_n_s_ss_2, __pyx_k_ss_2, sizeof(__pyx_k_ss_2), 0, 0, 1, 1}, + {&__pyx_n_s_ss_locals_genexpr, __pyx_k_ss_locals_genexpr, sizeof(__pyx_k_ss_locals_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, + {&__pyx_n_s_start_a, __pyx_k_start_a, sizeof(__pyx_k_start_a), 0, 0, 1, 1}, + {&__pyx_n_s_start_g, __pyx_k_start_g, sizeof(__pyx_k_start_g), 0, 0, 1, 1}, + {&__pyx_n_s_stats, __pyx_k_stats, sizeof(__pyx_k_stats), 0, 0, 1, 1}, + {&__pyx_n_s_stdev, __pyx_k_stdev, sizeof(__pyx_k_stdev), 0, 0, 1, 1}, + {&__pyx_n_s_stdev_2, __pyx_k_stdev_2, sizeof(__pyx_k_stdev_2), 0, 0, 1, 1}, + {&__pyx_n_s_stdev_derivative, __pyx_k_stdev_derivative, sizeof(__pyx_k_stdev_derivative), 0, 0, 1, 1}, + {&__pyx_n_s_stdev_z_split, __pyx_k_stdev_z_split, sizeof(__pyx_k_stdev_z_split), 0, 0, 1, 1}, + {&__pyx_n_s_strip_data, __pyx_k_strip_data, sizeof(__pyx_k_strip_data), 0, 0, 1, 1}, + {&__pyx_n_s_sum, __pyx_k_sum, sizeof(__pyx_k_sum), 0, 0, 1, 1}, + {&__pyx_n_s_sum_2, __pyx_k_sum_2, sizeof(__pyx_k_sum_2), 0, 0, 1, 1}, + {&__pyx_n_s_sum_locals_genexpr, __pyx_k_sum_locals_genexpr, sizeof(__pyx_k_sum_locals_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_table, __pyx_k_table, sizeof(__pyx_k_table), 0, 0, 1, 1}, + {&__pyx_n_s_tanh, __pyx_k_tanh, sizeof(__pyx_k_tanh), 0, 0, 1, 1}, + {&__pyx_n_s_tanh_regression, __pyx_k_tanh_regression, sizeof(__pyx_k_tanh_regression), 0, 0, 1, 1}, + {&__pyx_n_s_tanh_regression_locals_tanh, __pyx_k_tanh_regression_locals_tanh, sizeof(__pyx_k_tanh_regression_locals_tanh), 0, 0, 1, 1}, + {&__pyx_n_s_targets, __pyx_k_targets, sizeof(__pyx_k_targets), 0, 0, 1, 1}, + {&__pyx_n_s_temp, __pyx_k_temp, sizeof(__pyx_k_temp), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1}, + {&__pyx_n_s_time, __pyx_k_time, sizeof(__pyx_k_time), 0, 0, 1, 1}, + {&__pyx_n_s_tolist, __pyx_k_tolist, sizeof(__pyx_k_tolist), 0, 0, 1, 1}, + {&__pyx_n_s_torch, __pyx_k_torch, sizeof(__pyx_k_torch), 0, 0, 1, 1}, + {&__pyx_n_s_total, __pyx_k_total, sizeof(__pyx_k_total), 0, 0, 1, 1}, + {&__pyx_n_s_total2, __pyx_k_total2, sizeof(__pyx_k_total2), 0, 0, 1, 1}, + {&__pyx_n_s_ttest_ind, __pyx_k_ttest_ind, sizeof(__pyx_k_ttest_ind), 0, 0, 1, 1}, + {&__pyx_n_s_typ, __pyx_k_typ, sizeof(__pyx_k_typ), 0, 0, 1, 1}, + {&__pyx_n_s_uniform, __pyx_k_uniform, sizeof(__pyx_k_uniform), 0, 0, 1, 1}, + {&__pyx_n_s_vals, __pyx_k_vals, sizeof(__pyx_k_vals), 0, 0, 1, 1}, + {&__pyx_kp_s_vals_append, __pyx_k_vals_append, sizeof(__pyx_k_vals_append), 0, 0, 1, 0}, + {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, + {&__pyx_n_s_values, __pyx_k_values, sizeof(__pyx_k_values), 0, 0, 1, 1}, + {&__pyx_n_s_var, __pyx_k_var, sizeof(__pyx_k_var), 0, 0, 1, 1}, + {&__pyx_n_s_variance, __pyx_k_variance, sizeof(__pyx_k_variance), 0, 0, 1, 1}, + {&__pyx_n_s_variance_2, __pyx_k_variance_2, sizeof(__pyx_k_variance_2), 0, 0, 1, 1}, + {&__pyx_kp_s_variance_requires_at_least_two_d, __pyx_k_variance_requires_at_least_two_d, sizeof(__pyx_k_variance_requires_at_least_two_d), 0, 0, 1, 0}, + {&__pyx_n_s_version, __pyx_k_version, sizeof(__pyx_k_version), 0, 0, 1, 1}, + {&__pyx_n_s_w, __pyx_k_w, sizeof(__pyx_k_w), 0, 0, 1, 1}, + {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1}, + {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, + {&__pyx_n_s_x_fit, __pyx_k_x_fit, sizeof(__pyx_k_x_fit), 0, 0, 1, 1}, + {&__pyx_n_s_x_norm, __pyx_k_x_norm, sizeof(__pyx_k_x_norm), 0, 0, 1, 1}, + {&__pyx_n_s_x_test, __pyx_k_x_test, sizeof(__pyx_k_x_test), 0, 0, 1, 1}, + {&__pyx_n_s_x_train, __pyx_k_x_train, sizeof(__pyx_k_x_train), 0, 0, 1, 1}, + {&__pyx_n_s_xbar, __pyx_k_xbar, sizeof(__pyx_k_xbar), 0, 0, 1, 1}, + {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, + {&__pyx_n_s_y_fit, __pyx_k_y_fit, sizeof(__pyx_k_y_fit), 0, 0, 1, 1}, + {&__pyx_n_s_y_norm, __pyx_k_y_norm, sizeof(__pyx_k_y_norm), 0, 0, 1, 1}, + {&__pyx_n_s_y_test, __pyx_k_y_test, sizeof(__pyx_k_y_test), 0, 0, 1, 1}, + {&__pyx_n_s_y_train, __pyx_k_y_train, sizeof(__pyx_k_y_train), 0, 0, 1, 1}, + {&__pyx_kp_s_z, __pyx_k_z, sizeof(__pyx_k_z), 0, 0, 1, 0}, + {&__pyx_n_s_z_2, __pyx_k_z_2, sizeof(__pyx_k_z_2), 0, 0, 1, 1}, + {&__pyx_kp_s_z_3, __pyx_k_z_3, sizeof(__pyx_k_z_3), 0, 0, 1, 0}, + {&__pyx_kp_s_z_4, __pyx_k_z_4, sizeof(__pyx_k_z_4), 0, 0, 1, 0}, + {&__pyx_n_s_z_normalize, __pyx_k_z_normalize, sizeof(__pyx_k_z_normalize), 0, 0, 1, 1}, + {&__pyx_n_s_z_score, __pyx_k_z_score, sizeof(__pyx_k_z_score), 0, 0, 1, 1}, + {&__pyx_n_s_z_split, __pyx_k_z_split, sizeof(__pyx_k_z_split), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 157, __pyx_L1_error) + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 206, __pyx_L1_error) + __pyx_builtin_open = __Pyx_GetBuiltinName(__pyx_n_s_open); if (!__pyx_builtin_open) __PYX_ERR(0, 418, __pyx_L1_error) + __pyx_builtin_sorted = __Pyx_GetBuiltinName(__pyx_n_s_sorted); if (!__pyx_builtin_sorted) __PYX_ERR(0, 588, __pyx_L1_error) + __pyx_builtin_max = __Pyx_GetBuiltinName(__pyx_n_s_max); if (!__pyx_builtin_max) __PYX_ERR(0, 915, __pyx_L1_error) + __pyx_builtin_map = __Pyx_GetBuiltinName(__pyx_n_s_map); if (!__pyx_builtin_map) __PYX_ERR(0, 970, __pyx_L1_error) + __pyx_builtin_sum = __Pyx_GetBuiltinName(__pyx_n_s_sum); if (!__pyx_builtin_sum) __PYX_ERR(0, 979, __pyx_L1_error) + __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) __PYX_ERR(0, 986, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 1018, __pyx_L1_error) + __pyx_builtin_OverflowError = __Pyx_GetBuiltinName(__pyx_n_s_OverflowError); if (!__pyx_builtin_OverflowError) __PYX_ERR(0, 1037, __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); + + /* "analysis.py":418 + * + * def load_csv(filepath): + * with open(filepath, newline='') as csvfile: # <<<<<<<<<<<<<< + * file_array = list(csv.reader(csvfile)) + * csvfile.close() + */ + __pyx_tuple__3 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "analysis.py":606 + * pred_change = mean_derivative + * + * predictions.append(float(hist_data[-1:][0]) + pred_change) # <<<<<<<<<<<<<< + * + * i = i + delta + */ + __pyx_slice__4 = PySlice_New(__pyx_int_neg_1, Py_None, Py_None); if (unlikely(!__pyx_slice__4)) __PYX_ERR(0, 606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__4); + __Pyx_GIVEREF(__pyx_slice__4); + + /* "analysis.py":713 + * def tanh_regression(x, y): + * + * def tanh(x, a, b, c, d): # <<<<<<<<<<<<<< + * + * return a * np.tanh(b * (x - c)) + d + */ + __pyx_tuple__11 = PyTuple_Pack(5, __pyx_n_s_x, __pyx_n_s_a, __pyx_n_s_b, __pyx_n_s_c, __pyx_n_s_d); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 713, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(5, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_tanh, 713, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 713, __pyx_L1_error) + + /* "analysis.py":157 + * + * + * class error(ValueError): # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_tuple__18 = PyTuple_Pack(1, __pyx_builtin_ValueError); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); + + /* "analysis.py":161 + * + * + * def _init_device(setting, arg): # initiates computation device for ANNs # <<<<<<<<<<<<<< + * if setting == "cuda": + * try: + */ + __pyx_tuple__19 = PyTuple_Pack(2, __pyx_n_s_setting, __pyx_n_s_arg); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_init_device, 161, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 161, __pyx_L1_error) + + /* "analysis.py":184 + * c_logic = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("c_entities has attributes names, ids, positions, properties, and logic. __init__ takes self, 1d array of names, 1d array of ids, 2d array of positions, nd array of properties, and nd array of logic") + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] + */ + __pyx_tuple__21 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_debug, 184, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 184, __pyx_L1_error) + + /* "analysis.py":188 + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] + * + * def __init__(self, names, ids, pos, properties, logic): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + __pyx_tuple__23 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_names, __pyx_n_s_ids, __pyx_n_s_pos, __pyx_n_s_properties, __pyx_n_s_logic); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(6, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_init, 188, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(0, 188, __pyx_L1_error) + + /* "analysis.py":196 + * return None + * + * def append(self, n_name, n_id, n_pos, n_property, n_logic): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + __pyx_tuple__25 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_n_name, __pyx_n_s_n_id, __pyx_n_s_n_pos, __pyx_n_s_n_property, __pyx_n_s_n_logic); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); + __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(6, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_append, 196, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 196, __pyx_L1_error) + + /* "analysis.py":204 + * return None + * + * def edit(self, search, n_name, n_id, n_pos, n_property, n_logic): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_tuple__27 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_search, __pyx_n_s_n_name, __pyx_n_s_n_id, __pyx_n_s_n_pos, __pyx_n_s_n_property, __pyx_n_s_n_logic, __pyx_n_s_position, __pyx_n_s_i); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__27); + __Pyx_GIVEREF(__pyx_tuple__27); + __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(7, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_edit, 204, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 204, __pyx_L1_error) + + /* "analysis.py":226 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_tuple__29 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_search, __pyx_n_s_position, __pyx_n_s_i); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__29); + __Pyx_GIVEREF(__pyx_tuple__29); + __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(2, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_search, 226, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(0, 226, __pyx_L1_error) + + /* "analysis.py":234 + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_properties[position], self.c_logic[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] + * + */ + __pyx_tuple__31 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__31); + __Pyx_GIVEREF(__pyx_tuple__31); + __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_regurgitate, 234, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(0, 234, __pyx_L1_error) + + /* "analysis.py":246 + * c_effects = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("nc_entities (non-controlable entities) has attributes names, ids, positions, properties, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of positions, 2d array of properties, and 2d array of effects.") + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] + */ + __pyx_tuple__33 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__33); + __Pyx_GIVEREF(__pyx_tuple__33); + __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__33, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_debug, 246, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(0, 246, __pyx_L1_error) + + /* "analysis.py":250 + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] + * + * def __init__(self, names, ids, pos, properties, effects): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + __pyx_tuple__35 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_names, __pyx_n_s_ids, __pyx_n_s_pos, __pyx_n_s_properties, __pyx_n_s_effects); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__35); + __Pyx_GIVEREF(__pyx_tuple__35); + __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(6, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__35, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_init, 250, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(0, 250, __pyx_L1_error) + + /* "analysis.py":258 + * return None + * + * def append(self, n_name, n_id, n_pos, n_property, n_effect): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + __pyx_tuple__37 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_n_name, __pyx_n_s_n_id, __pyx_n_s_n_pos, __pyx_n_s_n_property, __pyx_n_s_n_effect); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__37); + __Pyx_GIVEREF(__pyx_tuple__37); + __pyx_codeobj__38 = (PyObject*)__Pyx_PyCode_New(6, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__37, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_append, 258, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__38)) __PYX_ERR(0, 258, __pyx_L1_error) + + /* "analysis.py":267 + * return None + * + * def edit(self, search, n_name, n_id, n_pos, n_property, n_effect): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_tuple__39 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_search, __pyx_n_s_n_name, __pyx_n_s_n_id, __pyx_n_s_n_pos, __pyx_n_s_n_property, __pyx_n_s_n_effect, __pyx_n_s_position, __pyx_n_s_i); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__39); + __Pyx_GIVEREF(__pyx_tuple__39); + __pyx_codeobj__40 = (PyObject*)__Pyx_PyCode_New(7, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__39, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_edit, 267, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__40)) __PYX_ERR(0, 267, __pyx_L1_error) + + /* "analysis.py":289 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_tuple__41 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_search, __pyx_n_s_position, __pyx_n_s_i); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__41); + __Pyx_GIVEREF(__pyx_tuple__41); + __pyx_codeobj__42 = (PyObject*)__Pyx_PyCode_New(2, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__41, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_search, 289, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__42)) __PYX_ERR(0, 289, __pyx_L1_error) + + /* "analysis.py":297 + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_properties[position], self.c_effects[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] + */ + __pyx_tuple__43 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__43); + __Pyx_GIVEREF(__pyx_tuple__43); + __pyx_codeobj__44 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__43, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_regurgitate, 297, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__44)) __PYX_ERR(0, 297, __pyx_L1_error) + + /* "analysis.py":309 + * c_effects = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("obstacles has atributes names, ids, positions, perimeters, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 3d array of perimeters, 2d array of effects.") + * return [self.c_names, self.c_ids, self.c_perim, self.c_effects] + */ + __pyx_tuple__45 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(0, 309, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__45); + __Pyx_GIVEREF(__pyx_tuple__45); + __pyx_codeobj__46 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_debug, 309, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__46)) __PYX_ERR(0, 309, __pyx_L1_error) + + /* "analysis.py":313 + * return [self.c_names, self.c_ids, self.c_perim, self.c_effects] + * + * def __init__(self, names, ids, perims, effects): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + __pyx_tuple__47 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_names, __pyx_n_s_ids, __pyx_n_s_perims, __pyx_n_s_effects); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__47); + __Pyx_GIVEREF(__pyx_tuple__47); + __pyx_codeobj__48 = (PyObject*)__Pyx_PyCode_New(5, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_init, 313, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__48)) __PYX_ERR(0, 313, __pyx_L1_error) + + /* "analysis.py":320 + * return None + * + * def append(self, n_name, n_id, n_perim, n_effect): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + __pyx_tuple__49 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_n_name, __pyx_n_s_n_id, __pyx_n_s_n_perim, __pyx_n_s_n_effect); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(0, 320, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__49); + __Pyx_GIVEREF(__pyx_tuple__49); + __pyx_codeobj__50 = (PyObject*)__Pyx_PyCode_New(5, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__49, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_append, 320, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__50)) __PYX_ERR(0, 320, __pyx_L1_error) + + /* "analysis.py":327 + * return None + * + * def edit(self, search, n_name, n_id, n_perim, n_effect): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_tuple__51 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_search, __pyx_n_s_n_name, __pyx_n_s_n_id, __pyx_n_s_n_perim, __pyx_n_s_n_effect, __pyx_n_s_position, __pyx_n_s_i); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 327, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__51); + __Pyx_GIVEREF(__pyx_tuple__51); + __pyx_codeobj__52 = (PyObject*)__Pyx_PyCode_New(6, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__51, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_edit, 327, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__52)) __PYX_ERR(0, 327, __pyx_L1_error) + + /* "analysis.py":347 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_tuple__53 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_search, __pyx_n_s_position, __pyx_n_s_i); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__53); + __Pyx_GIVEREF(__pyx_tuple__53); + __pyx_codeobj__54 = (PyObject*)__Pyx_PyCode_New(2, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__53, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_search, 347, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__54)) __PYX_ERR(0, 347, __pyx_L1_error) + + /* "analysis.py":355 + * return [self.c_names[position], self.c_ids[position], self.c_perim[position], self.c_effects[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * return[self.c_names, self.c_ids, self.c_perim, self.c_effects] + * + */ + __pyx_tuple__55 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(0, 355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__55); + __Pyx_GIVEREF(__pyx_tuple__55); + __pyx_codeobj__56 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__55, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_regurgitate, 355, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__56)) __PYX_ERR(0, 355, __pyx_L1_error) + + /* "analysis.py":366 + * c_effects = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("objectives has atributes names, ids, positions, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 1d array of effects.") + * return [self.c_names, self.c_ids, self.c_pos, self.c_effects] + */ + __pyx_tuple__57 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(0, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__57); + __Pyx_GIVEREF(__pyx_tuple__57); + __pyx_codeobj__58 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__57, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_debug, 366, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__58)) __PYX_ERR(0, 366, __pyx_L1_error) + + /* "analysis.py":370 + * return [self.c_names, self.c_ids, self.c_pos, self.c_effects] + * + * def __init__(self, names, ids, pos, effects): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + __pyx_tuple__59 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_names, __pyx_n_s_ids, __pyx_n_s_pos, __pyx_n_s_effects); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__59); + __Pyx_GIVEREF(__pyx_tuple__59); + __pyx_codeobj__60 = (PyObject*)__Pyx_PyCode_New(5, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__59, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_init, 370, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__60)) __PYX_ERR(0, 370, __pyx_L1_error) + + /* "analysis.py":377 + * return None + * + * def append(self, n_name, n_id, n_pos, n_effect): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + __pyx_tuple__61 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_n_name, __pyx_n_s_n_id, __pyx_n_s_n_pos, __pyx_n_s_n_effect); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(0, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__61); + __Pyx_GIVEREF(__pyx_tuple__61); + __pyx_codeobj__62 = (PyObject*)__Pyx_PyCode_New(5, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__61, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_append, 377, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__62)) __PYX_ERR(0, 377, __pyx_L1_error) + + /* "analysis.py":384 + * return None + * + * def edit(self, search, n_name, n_id, n_pos, n_effect): # <<<<<<<<<<<<<< + * position = 0 + * print(self.c_ids) + */ + __pyx_tuple__63 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_search, __pyx_n_s_n_name, __pyx_n_s_n_id, __pyx_n_s_n_pos, __pyx_n_s_n_effect, __pyx_n_s_position, __pyx_n_s_i); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__63); + __Pyx_GIVEREF(__pyx_tuple__63); + __pyx_codeobj__64 = (PyObject*)__Pyx_PyCode_New(6, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__63, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_edit, 384, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__64)) __PYX_ERR(0, 384, __pyx_L1_error) + + /* "analysis.py":405 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_tuple__65 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_search, __pyx_n_s_position, __pyx_n_s_i); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(0, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__65); + __Pyx_GIVEREF(__pyx_tuple__65); + __pyx_codeobj__66 = (PyObject*)__Pyx_PyCode_New(2, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__65, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_search, 405, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__66)) __PYX_ERR(0, 405, __pyx_L1_error) + + /* "analysis.py":413 + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_effects[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * return[self.c_names, self.c_ids, self.c_pos, self.c_effects] + * + */ + __pyx_tuple__67 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(0, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__67); + __Pyx_GIVEREF(__pyx_tuple__67); + __pyx_codeobj__68 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__67, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_regurgitate, 413, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__68)) __PYX_ERR(0, 413, __pyx_L1_error) + + /* "analysis.py":417 + * + * + * def load_csv(filepath): # <<<<<<<<<<<<<< + * with open(filepath, newline='') as csvfile: + * file_array = list(csv.reader(csvfile)) + */ + __pyx_tuple__69 = PyTuple_Pack(3, __pyx_n_s_filepath, __pyx_n_s_csvfile, __pyx_n_s_file_array); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(0, 417, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__69); + __Pyx_GIVEREF(__pyx_tuple__69); + __pyx_codeobj__70 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__69, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_load_csv, 417, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__70)) __PYX_ERR(0, 417, __pyx_L1_error) + + /* "analysis.py":425 + * + * # data=array, mode = ['1d':1d_basic_stats, 'column':c_basic_stats, 'row':r_basic_stats], arg for mode 1 or mode 2 for column or row + * def basic_stats(data, method, arg): # <<<<<<<<<<<<<< + * + * if method == 'debug': + */ + __pyx_tuple__71 = PyTuple_Pack(13, __pyx_n_s_data, __pyx_n_s_method, __pyx_n_s_arg, __pyx_n_s_data_t, __pyx_n_s_i, __pyx_n_s_mean_2, __pyx_n_s_median_2, __pyx_n_s_mode_2, __pyx_n_s_stdev_2, __pyx_n_s_variance_2, __pyx_n_s_c_data, __pyx_n_s_c_data_sorted, __pyx_n_s_r_data); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(0, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__71); + __Pyx_GIVEREF(__pyx_tuple__71); + __pyx_codeobj__72 = (PyObject*)__Pyx_PyCode_New(3, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__71, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_basic_stats, 425, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__72)) __PYX_ERR(0, 425, __pyx_L1_error) + + /* "analysis.py":511 + * + * # returns z score with inputs of point, mean and standard deviation of spread + * def z_score(point, mean, stdev): # <<<<<<<<<<<<<< + * score = (point - mean) / stdev + * return score + */ + __pyx_tuple__73 = PyTuple_Pack(4, __pyx_n_s_point, __pyx_n_s_mean, __pyx_n_s_stdev, __pyx_n_s_score); if (unlikely(!__pyx_tuple__73)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__73); + __Pyx_GIVEREF(__pyx_tuple__73); + __pyx_codeobj__74 = (PyObject*)__Pyx_PyCode_New(3, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__73, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_z_score, 511, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__74)) __PYX_ERR(0, 511, __pyx_L1_error) + + /* "analysis.py":517 + * + * # mode is either 'x' or 'y' or 'both' depending on the variable(s) to be normalized + * def z_normalize(x, y, mode): # <<<<<<<<<<<<<< + * + * x_norm = [] + */ + __pyx_tuple__75 = PyTuple_Pack(13, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_mode, __pyx_n_s_x_norm, __pyx_n_s_y_norm, __pyx_n_s_mean, __pyx_n_s_stdev, __pyx_n_s_mean_2, __pyx_n_s_median_2, __pyx_n_s_mode_2, __pyx_n_s_stdev_2, __pyx_n_s_variance_2, __pyx_n_s_i); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(0, 517, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__75); + __Pyx_GIVEREF(__pyx_tuple__75); + __pyx_codeobj__76 = (PyObject*)__Pyx_PyCode_New(3, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__75, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_z_normalize, 517, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__76)) __PYX_ERR(0, 517, __pyx_L1_error) + + /* "analysis.py":560 + * + * # returns n-th percentile of spread given mean, standard deviation, lower z-score, and upper z-score + * def stdev_z_split(mean, stdev, delta, low_bound, high_bound): # <<<<<<<<<<<<<< + * + * z_split = [] + */ + __pyx_tuple__77 = PyTuple_Pack(7, __pyx_n_s_mean, __pyx_n_s_stdev, __pyx_n_s_delta, __pyx_n_s_low_bound, __pyx_n_s_high_bound, __pyx_n_s_z_split, __pyx_n_s_i); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(0, 560, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__77); + __Pyx_GIVEREF(__pyx_tuple__77); + __pyx_codeobj__78 = (PyObject*)__Pyx_PyCode_New(5, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__77, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_stdev_z_split, 560, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__78)) __PYX_ERR(0, 560, __pyx_L1_error) + + /* "analysis.py":575 + * + * + * def histo_analysis(hist_data, delta, low_bound, high_bound): # <<<<<<<<<<<<<< + * + * if hist_data == 'debug': + */ + __pyx_tuple__79 = PyTuple_Pack(11, __pyx_n_s_hist_data, __pyx_n_s_delta, __pyx_n_s_low_bound, __pyx_n_s_high_bound, __pyx_n_s_derivative, __pyx_n_s_i, __pyx_n_s_derivative_sorted, __pyx_n_s_mean_derivative, __pyx_n_s_stdev_derivative, __pyx_n_s_predictions, __pyx_n_s_pred_change); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(0, 575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__79); + __Pyx_GIVEREF(__pyx_tuple__79); + __pyx_codeobj__80 = (PyObject*)__Pyx_PyCode_New(4, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__79, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_histo_analysis, 575, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__80)) __PYX_ERR(0, 575, __pyx_L1_error) + + /* "analysis.py":613 + * + * + * def poly_regression(x, y, power): # <<<<<<<<<<<<<< + * + * if x == "null": # if x is 'null', then x will be filled with integer points between 1 and the size of y + */ + __pyx_tuple__81 = PyTuple_Pack(10, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_power, __pyx_n_s_i, __pyx_n_s_reg_eq, __pyx_n_s_eq_str, __pyx_n_s_vals, __pyx_n_s_z_2, __pyx_n_s_rms, __pyx_n_s_r2_d2); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(0, 613, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__81); + __Pyx_GIVEREF(__pyx_tuple__81); + __pyx_codeobj__82 = (PyObject*)__Pyx_PyCode_New(3, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__81, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_poly_regression, 613, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__82)) __PYX_ERR(0, 613, __pyx_L1_error) + + /* "analysis.py":649 + * + * + * def log_regression(x, y, base): # <<<<<<<<<<<<<< + * + * x_fit = [] + */ + __pyx_tuple__83 = PyTuple_Pack(11, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_base, __pyx_n_s_x_fit, __pyx_n_s_i, __pyx_n_s_reg_eq, __pyx_n_s_q_str, __pyx_n_s_vals, __pyx_n_s_z_2, __pyx_n_s_rms, __pyx_n_s_r2_d2); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(0, 649, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__83); + __Pyx_GIVEREF(__pyx_tuple__83); + __pyx_codeobj__84 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__83, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_log_regression, 649, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__84)) __PYX_ERR(0, 649, __pyx_L1_error) + + /* "analysis.py":680 + * + * + * def exp_regression(x, y, base): # <<<<<<<<<<<<<< + * + * y_fit = [] + */ + __pyx_tuple__85 = PyTuple_Pack(11, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_base, __pyx_n_s_y_fit, __pyx_n_s_i, __pyx_n_s_reg_eq, __pyx_n_s_eq_str, __pyx_n_s_vals, __pyx_n_s_z_2, __pyx_n_s_rms, __pyx_n_s_r2_d2); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(0, 680, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__85); + __Pyx_GIVEREF(__pyx_tuple__85); + __pyx_codeobj__86 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__85, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_exp_regression, 680, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__86)) __PYX_ERR(0, 680, __pyx_L1_error) + + /* "analysis.py":711 + * + * + * def tanh_regression(x, y): # <<<<<<<<<<<<<< + * + * def tanh(x, a, b, c, d): + */ + __pyx_tuple__87 = PyTuple_Pack(11, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_tanh, __pyx_n_s_tanh, __pyx_n_s_reg_eq, __pyx_n_s_eq_str, __pyx_n_s_vals, __pyx_n_s_i, __pyx_n_s_z_2, __pyx_n_s_rms, __pyx_n_s_r2_d2); if (unlikely(!__pyx_tuple__87)) __PYX_ERR(0, 711, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__87); + __Pyx_GIVEREF(__pyx_tuple__87); + __pyx_codeobj__88 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__87, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_tanh_regression, 711, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__88)) __PYX_ERR(0, 711, __pyx_L1_error) + + /* "analysis.py":735 + * + * + * def r_squared(predictions, targets): # assumes equal size inputs # <<<<<<<<<<<<<< + * + * return metrics.r2_score(np.array(targets), np.array(predictions)) + */ + __pyx_tuple__89 = PyTuple_Pack(2, __pyx_n_s_predictions, __pyx_n_s_targets); if (unlikely(!__pyx_tuple__89)) __PYX_ERR(0, 735, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__89); + __Pyx_GIVEREF(__pyx_tuple__89); + __pyx_codeobj__90 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__89, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_r_squared, 735, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__90)) __PYX_ERR(0, 735, __pyx_L1_error) + + /* "analysis.py":740 + * + * + * def rms(predictions, targets): # assumes equal size inputs # <<<<<<<<<<<<<< + * + * _sum = 0 + */ + __pyx_tuple__91 = PyTuple_Pack(4, __pyx_n_s_predictions, __pyx_n_s_targets, __pyx_n_s_sum_2, __pyx_n_s_i); if (unlikely(!__pyx_tuple__91)) __PYX_ERR(0, 740, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__91); + __Pyx_GIVEREF(__pyx_tuple__91); + __pyx_codeobj__92 = (PyObject*)__Pyx_PyCode_New(2, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__91, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_rms_2, 740, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__92)) __PYX_ERR(0, 740, __pyx_L1_error) + + /* "analysis.py":750 + * + * + * def calc_overfit(equation, rms_train, r2_train, x_test, y_test): # <<<<<<<<<<<<<< + * + * # performance overfit = performance(train) - performance(test) where performance is r^2 + */ + __pyx_tuple__93 = PyTuple_Pack(10, __pyx_n_s_equation, __pyx_n_s_rms_train, __pyx_n_s_r2_train, __pyx_n_s_x_test, __pyx_n_s_y_test, __pyx_n_s_vals, __pyx_n_s_i, __pyx_n_s_z_2, __pyx_n_s_r2_test, __pyx_n_s_rms_test); if (unlikely(!__pyx_tuple__93)) __PYX_ERR(0, 750, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__93); + __Pyx_GIVEREF(__pyx_tuple__93); + __pyx_codeobj__94 = (PyObject*)__Pyx_PyCode_New(5, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__93, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_calc_overfit, 750, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__94)) __PYX_ERR(0, 750, __pyx_L1_error) + + /* "analysis.py":769 + * + * + * def strip_data(data, mode): # <<<<<<<<<<<<<< + * + * if mode == "adam": # x is the row number, y are the data + */ + __pyx_tuple__95 = PyTuple_Pack(2, __pyx_n_s_data, __pyx_n_s_mode); if (unlikely(!__pyx_tuple__95)) __PYX_ERR(0, 769, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__95); + __Pyx_GIVEREF(__pyx_tuple__95); + __pyx_codeobj__96 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__95, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_strip_data, 769, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__96)) __PYX_ERR(0, 769, __pyx_L1_error) + + /* "analysis.py":782 + * + * # _range in poly regression is the range of powers tried, and in log/exp it is the inverse of the stepsize taken from -1000 to 1000 + * def optimize_regression(x, y, _range, resolution): # <<<<<<<<<<<<<< + * # usage not: for demonstration purpose only, performance is shit + * if type(resolution) != int: + */ + __pyx_tuple__97 = PyTuple_Pack(15, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_range_2, __pyx_n_s_resolution, __pyx_n_s_x_train, __pyx_n_s_y_train, __pyx_n_s_i, __pyx_n_s_x_test, __pyx_n_s_y_test, __pyx_n_s_index, __pyx_n_s_eqs, __pyx_n_s_rmss, __pyx_n_s_r2s, __pyx_n_s_z_2, __pyx_n_s_overfit); if (unlikely(!__pyx_tuple__97)) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__97); + __Pyx_GIVEREF(__pyx_tuple__97); + __pyx_codeobj__98 = (PyObject*)__Pyx_PyCode_New(4, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__97, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_optimize_regression, 782, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__98)) __PYX_ERR(0, 782, __pyx_L1_error) + + /* "analysis.py":872 + * + * + * def select_best_regression(eqs, rmss, r2s, overfit, selector): # <<<<<<<<<<<<<< + * + * b_eq = "" + */ + __pyx_tuple__99 = PyTuple_Pack(10, __pyx_n_s_eqs, __pyx_n_s_rmss, __pyx_n_s_r2s, __pyx_n_s_overfit, __pyx_n_s_selector, __pyx_n_s_b_eq, __pyx_n_s_b_rms, __pyx_n_s_b_r2, __pyx_n_s_b_overfit, __pyx_n_s_ind); if (unlikely(!__pyx_tuple__99)) __PYX_ERR(0, 872, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__99); + __Pyx_GIVEREF(__pyx_tuple__99); + __pyx_codeobj__100 = (PyObject*)__Pyx_PyCode_New(5, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__99, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_select_best_regression, 872, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__100)) __PYX_ERR(0, 872, __pyx_L1_error) + + /* "analysis.py":901 + * + * + * def p_value(x, y): # takes 2 1d arrays # <<<<<<<<<<<<<< + * + * return stats.ttest_ind(x, y)[1] + */ + __pyx_tuple__101 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_y); if (unlikely(!__pyx_tuple__101)) __PYX_ERR(0, 901, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__101); + __Pyx_GIVEREF(__pyx_tuple__101); + __pyx_codeobj__102 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__101, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_p_value, 901, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__102)) __PYX_ERR(0, 901, __pyx_L1_error) + + /* "analysis.py":907 + * + * # assumes that rows are the independent variable and columns are the dependant. also assumes that time flows from lowest column to highest column. + * def basic_analysis(data): # <<<<<<<<<<<<<< + * + * row = len(data) + */ + __pyx_tuple__103 = PyTuple_Pack(8, __pyx_n_s_data, __pyx_n_s_row, __pyx_n_s_column, __pyx_n_s_i, __pyx_n_s_column_max, __pyx_n_s_row_b_stats, __pyx_n_s_row_histo, __pyx_n_s_column_b_stats); if (unlikely(!__pyx_tuple__103)) __PYX_ERR(0, 907, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__103); + __Pyx_GIVEREF(__pyx_tuple__103); + __pyx_codeobj__104 = (PyObject*)__Pyx_PyCode_New(1, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__103, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_basic_analysis, 907, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__104)) __PYX_ERR(0, 907, __pyx_L1_error) + + /* "analysis.py":931 + * + * + * def benchmark(x, y): # <<<<<<<<<<<<<< + * + * start_g = time.time() + */ + __pyx_tuple__105 = PyTuple_Pack(6, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_start_g, __pyx_n_s_end_g, __pyx_n_s_start_a, __pyx_n_s_end_a); if (unlikely(!__pyx_tuple__105)) __PYX_ERR(0, 931, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__105); + __Pyx_GIVEREF(__pyx_tuple__105); + __pyx_codeobj__106 = (PyObject*)__Pyx_PyCode_New(2, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__105, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_benchmark, 931, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__106)) __PYX_ERR(0, 931, __pyx_L1_error) + + /* "analysis.py":944 + * + * + * def generate_data(filename, x, y, low, high): # <<<<<<<<<<<<<< + * + * file = open(filename, "w") + */ + __pyx_tuple__107 = PyTuple_Pack(9, __pyx_n_s_filename, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_low, __pyx_n_s_high, __pyx_n_s_file, __pyx_n_s_i, __pyx_n_s_temp, __pyx_n_s_j); if (unlikely(!__pyx_tuple__107)) __PYX_ERR(0, 944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__107); + __Pyx_GIVEREF(__pyx_tuple__107); + __pyx_codeobj__108 = (PyObject*)__Pyx_PyCode_New(5, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__107, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_generate_data, 944, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__108)) __PYX_ERR(0, 944, __pyx_L1_error) + + /* "analysis.py":958 + * + * + * class StatisticsError(ValueError): # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_tuple__109 = PyTuple_Pack(1, __pyx_builtin_ValueError); if (unlikely(!__pyx_tuple__109)) __PYX_ERR(0, 958, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__109); + __Pyx_GIVEREF(__pyx_tuple__109); + + /* "analysis.py":962 + * + * + * def _sum(data, start=0): # <<<<<<<<<<<<<< + * count = 0 + * n, d = _exact_ratio(start) + */ + __pyx_tuple__110 = PyTuple_Pack(13, __pyx_n_s_data, __pyx_n_s_start, __pyx_n_s_count, __pyx_n_s_n, __pyx_n_s_d, __pyx_n_s_partials, __pyx_n_s_partials_get, __pyx_n_s_T, __pyx_n_s_typ, __pyx_n_s_values, __pyx_n_s_total, __pyx_n_s_genexpr, __pyx_n_s_genexpr); if (unlikely(!__pyx_tuple__110)) __PYX_ERR(0, 962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__110); + __Pyx_GIVEREF(__pyx_tuple__110); + __pyx_codeobj__111 = (PyObject*)__Pyx_PyCode_New(2, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__110, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_sum_2, 962, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__111)) __PYX_ERR(0, 962, __pyx_L1_error) + __pyx_tuple__112 = PyTuple_Pack(1, ((PyObject *)__pyx_int_0)); if (unlikely(!__pyx_tuple__112)) __PYX_ERR(0, 962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__112); + __Pyx_GIVEREF(__pyx_tuple__112); + + /* "analysis.py":983 + * + * + * def _isfinite(x): # <<<<<<<<<<<<<< + * try: + * return x.is_finite() # Likely a Decimal. + */ + __pyx_tuple__113 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__113)) __PYX_ERR(0, 983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__113); + __Pyx_GIVEREF(__pyx_tuple__113); + __pyx_codeobj__114 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__113, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_isfinite, 983, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__114)) __PYX_ERR(0, 983, __pyx_L1_error) + + /* "analysis.py":990 + * + * + * def _coerce(T, S): # <<<<<<<<<<<<<< + * + * assert T is not bool, "initial type T is bool" + */ + __pyx_tuple__115 = PyTuple_Pack(3, __pyx_n_s_T, __pyx_n_s_S, __pyx_n_s_msg); if (unlikely(!__pyx_tuple__115)) __PYX_ERR(0, 990, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__115); + __Pyx_GIVEREF(__pyx_tuple__115); + __pyx_codeobj__116 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__115, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_coerce, 990, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__116)) __PYX_ERR(0, 990, __pyx_L1_error) + + /* "analysis.py":1021 + * + * + * def _exact_ratio(x): # <<<<<<<<<<<<<< + * + * try: + */ + __pyx_tuple__117 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_msg); if (unlikely(!__pyx_tuple__117)) __PYX_ERR(0, 1021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__117); + __Pyx_GIVEREF(__pyx_tuple__117); + __pyx_codeobj__118 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__117, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_exact_ratio, 1021, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__118)) __PYX_ERR(0, 1021, __pyx_L1_error) + + /* "analysis.py":1045 + * + * + * def _convert(value, T): # <<<<<<<<<<<<<< + * + * if type(value) is T: + */ + __pyx_tuple__119 = PyTuple_Pack(2, __pyx_n_s_value, __pyx_n_s_T); if (unlikely(!__pyx_tuple__119)) __PYX_ERR(0, 1045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__119); + __Pyx_GIVEREF(__pyx_tuple__119); + __pyx_codeobj__120 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__119, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_convert, 1045, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__120)) __PYX_ERR(0, 1045, __pyx_L1_error) + + /* "analysis.py":1062 + * + * + * def _counts(data): # <<<<<<<<<<<<<< + * + * table = collections.Counter(iter(data)).most_common() + */ + __pyx_tuple__121 = PyTuple_Pack(4, __pyx_n_s_data, __pyx_n_s_table, __pyx_n_s_maxfreq, __pyx_n_s_i); if (unlikely(!__pyx_tuple__121)) __PYX_ERR(0, 1062, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__121); + __Pyx_GIVEREF(__pyx_tuple__121); + __pyx_codeobj__122 = (PyObject*)__Pyx_PyCode_New(1, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__121, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_counts, 1062, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__122)) __PYX_ERR(0, 1062, __pyx_L1_error) + + /* "analysis.py":1076 + * + * + * def _find_lteq(a, x): # <<<<<<<<<<<<<< + * + * i = bisect_left(a, x) + */ + __pyx_tuple__123 = PyTuple_Pack(3, __pyx_n_s_a, __pyx_n_s_x, __pyx_n_s_i); if (unlikely(!__pyx_tuple__123)) __PYX_ERR(0, 1076, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__123); + __Pyx_GIVEREF(__pyx_tuple__123); + __pyx_codeobj__124 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__123, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_find_lteq, 1076, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__124)) __PYX_ERR(0, 1076, __pyx_L1_error) + + /* "analysis.py":1084 + * + * + * def _find_rteq(a, l, x): # <<<<<<<<<<<<<< + * + * i = bisect_right(a, x, lo=l) + */ + __pyx_tuple__125 = PyTuple_Pack(4, __pyx_n_s_a, __pyx_n_s_l, __pyx_n_s_x, __pyx_n_s_i); if (unlikely(!__pyx_tuple__125)) __PYX_ERR(0, 1084, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__125); + __Pyx_GIVEREF(__pyx_tuple__125); + __pyx_codeobj__126 = (PyObject*)__Pyx_PyCode_New(3, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__125, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_find_rteq, 1084, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__126)) __PYX_ERR(0, 1084, __pyx_L1_error) + + /* "analysis.py":1092 + * + * + * def _fail_neg(values, errmsg='negative value'): # <<<<<<<<<<<<<< + * + * for x in values: + */ + __pyx_tuple__127 = PyTuple_Pack(3, __pyx_n_s_values, __pyx_n_s_errmsg, __pyx_n_s_x); if (unlikely(!__pyx_tuple__127)) __PYX_ERR(0, 1092, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__127); + __Pyx_GIVEREF(__pyx_tuple__127); + __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__127, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_fail_neg, 1092, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 1092, __pyx_L1_error) + __pyx_tuple__128 = PyTuple_Pack(1, ((PyObject*)__pyx_kp_s_negative_value)); if (unlikely(!__pyx_tuple__128)) __PYX_ERR(0, 1092, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__128); + __Pyx_GIVEREF(__pyx_tuple__128); + + /* "analysis.py":1100 + * + * + * def mean(data): # <<<<<<<<<<<<<< + * + * if iter(data) is data: + */ + __pyx_tuple__129 = PyTuple_Pack(5, __pyx_n_s_data, __pyx_n_s_n, __pyx_n_s_T, __pyx_n_s_total, __pyx_n_s_count); if (unlikely(!__pyx_tuple__129)) __PYX_ERR(0, 1100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__129); + __Pyx_GIVEREF(__pyx_tuple__129); + __pyx_codeobj__130 = (PyObject*)__Pyx_PyCode_New(1, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__129, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_mean, 1100, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__130)) __PYX_ERR(0, 1100, __pyx_L1_error) + + /* "analysis.py":1112 + * + * + * def median(data): # <<<<<<<<<<<<<< + * + * data = sorted(data) + */ + __pyx_tuple__131 = PyTuple_Pack(3, __pyx_n_s_data, __pyx_n_s_n, __pyx_n_s_i); if (unlikely(!__pyx_tuple__131)) __PYX_ERR(0, 1112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__131); + __Pyx_GIVEREF(__pyx_tuple__131); + __pyx_codeobj__132 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__131, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_median, 1112, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__132)) __PYX_ERR(0, 1112, __pyx_L1_error) + + /* "analysis.py":1125 + * + * + * def mode(data): # <<<<<<<<<<<<<< + * + * table = _counts(data) + */ + __pyx_tuple__133 = PyTuple_Pack(2, __pyx_n_s_data, __pyx_n_s_table); if (unlikely(!__pyx_tuple__133)) __PYX_ERR(0, 1125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__133); + __Pyx_GIVEREF(__pyx_tuple__133); + __pyx_codeobj__134 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__133, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_mode, 1125, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__134)) __PYX_ERR(0, 1125, __pyx_L1_error) + + /* "analysis.py":1138 + * + * + * def _ss(data, c=None): # <<<<<<<<<<<<<< + * + * if c is None: + */ + __pyx_tuple__135 = PyTuple_Pack(11, __pyx_n_s_data, __pyx_n_s_c, __pyx_n_s_T, __pyx_n_s_total, __pyx_n_s_count, __pyx_n_s_U, __pyx_n_s_total2, __pyx_n_s_count2, __pyx_n_s_genexpr, __pyx_n_s_genexpr, __pyx_n_s_genexpr); if (unlikely(!__pyx_tuple__135)) __PYX_ERR(0, 1138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__135); + __Pyx_GIVEREF(__pyx_tuple__135); + __pyx_codeobj__136 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__135, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_ss, 1138, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__136)) __PYX_ERR(0, 1138, __pyx_L1_error) + __pyx_tuple__137 = PyTuple_Pack(1, ((PyObject *)Py_None)); if (unlikely(!__pyx_tuple__137)) __PYX_ERR(0, 1138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__137); + __Pyx_GIVEREF(__pyx_tuple__137); + + /* "analysis.py":1151 + * + * + * def variance(data, xbar=None): # <<<<<<<<<<<<<< + * + * if iter(data) is data: + */ + __pyx_tuple__138 = PyTuple_Pack(5, __pyx_n_s_data, __pyx_n_s_xbar, __pyx_n_s_n, __pyx_n_s_T, __pyx_n_s_ss_2); if (unlikely(!__pyx_tuple__138)) __PYX_ERR(0, 1151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__138); + __Pyx_GIVEREF(__pyx_tuple__138); + __pyx_codeobj__139 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__138, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_variance, 1151, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__139)) __PYX_ERR(0, 1151, __pyx_L1_error) + __pyx_tuple__140 = PyTuple_Pack(1, ((PyObject *)Py_None)); if (unlikely(!__pyx_tuple__140)) __PYX_ERR(0, 1151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__140); + __Pyx_GIVEREF(__pyx_tuple__140); + + /* "analysis.py":1162 + * + * + * def stdev(data, xbar=None): # <<<<<<<<<<<<<< + * + * var = variance(data, xbar) + */ + __pyx_tuple__141 = PyTuple_Pack(3, __pyx_n_s_data, __pyx_n_s_xbar, __pyx_n_s_var); if (unlikely(!__pyx_tuple__141)) __PYX_ERR(0, 1162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__141); + __Pyx_GIVEREF(__pyx_tuple__141); + __pyx_codeobj__142 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__141, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_analysis_py, __pyx_n_s_stdev, 1162, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__142)) __PYX_ERR(0, 1162, __pyx_L1_error) + __pyx_tuple__143 = PyTuple_Pack(1, ((PyObject *)Py_None)); if (unlikely(!__pyx_tuple__143)) __PYX_ERR(0, 1162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__143); + __Pyx_GIVEREF(__pyx_tuple__143); + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + __pyx_umethod_PyDict_Type_get.type = (PyObject*)&PyDict_Type; + __pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type; + __pyx_umethod_PyList_Type_remove.type = (PyObject*)&PyList_Type; + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_float_0_67449 = PyFloat_FromDouble(0.67449); if (unlikely(!__pyx_float_0_67449)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_neg_0_5 = PyFloat_FromDouble(-0.5); if (unlikely(!__pyx_float_neg_0_5)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_neg_0_67449 = PyFloat_FromDouble(-0.67449); if (unlikely(!__pyx_float_neg_0_67449)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_10 = PyInt_FromLong(10); if (unlikely(!__pyx_int_10)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_100 = PyInt_FromLong(100); if (unlikely(!__pyx_int_100)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_10 = PyInt_FromLong(-10); if (unlikely(!__pyx_int_neg_10)) __PYX_ERR(0, 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_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 + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + if (PyType_Ready(&__pyx_type_8analysis___pyx_scope_struct___sum) < 0) __PYX_ERR(0, 962, __pyx_L1_error) + __pyx_type_8analysis___pyx_scope_struct___sum.tp_print = 0; + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_8analysis___pyx_scope_struct___sum.tp_dictoffset && __pyx_type_8analysis___pyx_scope_struct___sum.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type_8analysis___pyx_scope_struct___sum.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + __pyx_ptype_8analysis___pyx_scope_struct___sum = &__pyx_type_8analysis___pyx_scope_struct___sum; + if (PyType_Ready(&__pyx_type_8analysis___pyx_scope_struct_1_genexpr) < 0) __PYX_ERR(0, 979, __pyx_L1_error) + __pyx_type_8analysis___pyx_scope_struct_1_genexpr.tp_print = 0; + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_8analysis___pyx_scope_struct_1_genexpr.tp_dictoffset && __pyx_type_8analysis___pyx_scope_struct_1_genexpr.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type_8analysis___pyx_scope_struct_1_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + __pyx_ptype_8analysis___pyx_scope_struct_1_genexpr = &__pyx_type_8analysis___pyx_scope_struct_1_genexpr; + if (PyType_Ready(&__pyx_type_8analysis___pyx_scope_struct_2__fail_neg) < 0) __PYX_ERR(0, 1092, __pyx_L1_error) + __pyx_type_8analysis___pyx_scope_struct_2__fail_neg.tp_print = 0; + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_8analysis___pyx_scope_struct_2__fail_neg.tp_dictoffset && __pyx_type_8analysis___pyx_scope_struct_2__fail_neg.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type_8analysis___pyx_scope_struct_2__fail_neg.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + __pyx_ptype_8analysis___pyx_scope_struct_2__fail_neg = &__pyx_type_8analysis___pyx_scope_struct_2__fail_neg; + if (PyType_Ready(&__pyx_type_8analysis___pyx_scope_struct_3__ss) < 0) __PYX_ERR(0, 1138, __pyx_L1_error) + __pyx_type_8analysis___pyx_scope_struct_3__ss.tp_print = 0; + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_8analysis___pyx_scope_struct_3__ss.tp_dictoffset && __pyx_type_8analysis___pyx_scope_struct_3__ss.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type_8analysis___pyx_scope_struct_3__ss.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + __pyx_ptype_8analysis___pyx_scope_struct_3__ss = &__pyx_type_8analysis___pyx_scope_struct_3__ss; + if (PyType_Ready(&__pyx_type_8analysis___pyx_scope_struct_4_genexpr) < 0) __PYX_ERR(0, 1142, __pyx_L1_error) + __pyx_type_8analysis___pyx_scope_struct_4_genexpr.tp_print = 0; + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_8analysis___pyx_scope_struct_4_genexpr.tp_dictoffset && __pyx_type_8analysis___pyx_scope_struct_4_genexpr.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type_8analysis___pyx_scope_struct_4_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + __pyx_ptype_8analysis___pyx_scope_struct_4_genexpr = &__pyx_type_8analysis___pyx_scope_struct_4_genexpr; + if (PyType_Ready(&__pyx_type_8analysis___pyx_scope_struct_5_genexpr) < 0) __PYX_ERR(0, 1144, __pyx_L1_error) + __pyx_type_8analysis___pyx_scope_struct_5_genexpr.tp_print = 0; + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_8analysis___pyx_scope_struct_5_genexpr.tp_dictoffset && __pyx_type_8analysis___pyx_scope_struct_5_genexpr.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type_8analysis___pyx_scope_struct_5_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + __pyx_ptype_8analysis___pyx_scope_struct_5_genexpr = &__pyx_type_8analysis___pyx_scope_struct_5_genexpr; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +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 + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#if PY_MAJOR_VERSION < 3 +#ifdef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC void +#else +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#endif +#else +#ifdef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initanalysis(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initanalysis(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_analysis(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_analysis(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_analysis(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'analysis' 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_analysis(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 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(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #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("analysis", __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(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 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(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_analysis) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "analysis")) { + if (unlikely(PyDict_SetItemString(modules, "analysis", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + (void)__Pyx_modinit_function_export_code(); + if (unlikely(__Pyx_modinit_type_init_code() != 0)) goto __pyx_L1_error; + (void)__Pyx_modinit_type_import_code(); + (void)__Pyx_modinit_variable_import_code(); + (void)__Pyx_modinit_function_import_code(); + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "analysis.py":10 + * # setup: + * + * __version__ = "1.0.8.005" # <<<<<<<<<<<<<< + * + * # changelog should be viewed using print(analysis.__changelog__) + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_version, __pyx_kp_s_1_0_8_005) < 0) __PYX_ERR(0, 10, __pyx_L1_error) + + /* "analysis.py":13 + * + * # changelog should be viewed using print(analysis.__changelog__) + * __changelog__ = """changelog: # <<<<<<<<<<<<<< + * 1.0.8.005: + * - minor fixes + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_changelog, __pyx_kp_s_changelog_1_0_8_005_minor_fixes) < 0) __PYX_ERR(0, 13, __pyx_L1_error) + + /* "analysis.py":102 + * + * __author__ = ( + * "Arthur Lu , " # <<<<<<<<<<<<<< + * "Jacob Levine ," + * ) + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_author, __pyx_kp_s_Arthur_Lu_arthurlu_ttic_edu_Jaco) < 0) __PYX_ERR(0, 101, __pyx_L1_error) + + /* "analysis.py":106 + * ) + * + * __all__ = [ # <<<<<<<<<<<<<< + * '_init_device', + * 'c_entities', + */ + __pyx_t_1 = PyList_New(21); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_init_device); + __Pyx_GIVEREF(__pyx_n_s_init_device); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_init_device); + __Pyx_INCREF(__pyx_n_s_c_entities); + __Pyx_GIVEREF(__pyx_n_s_c_entities); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_c_entities); + __Pyx_INCREF(__pyx_n_s_nc_entities); + __Pyx_GIVEREF(__pyx_n_s_nc_entities); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_nc_entities); + __Pyx_INCREF(__pyx_n_s_obstacles); + __Pyx_GIVEREF(__pyx_n_s_obstacles); + PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_obstacles); + __Pyx_INCREF(__pyx_n_s_objectives); + __Pyx_GIVEREF(__pyx_n_s_objectives); + PyList_SET_ITEM(__pyx_t_1, 4, __pyx_n_s_objectives); + __Pyx_INCREF(__pyx_n_s_load_csv); + __Pyx_GIVEREF(__pyx_n_s_load_csv); + PyList_SET_ITEM(__pyx_t_1, 5, __pyx_n_s_load_csv); + __Pyx_INCREF(__pyx_n_s_basic_stats); + __Pyx_GIVEREF(__pyx_n_s_basic_stats); + PyList_SET_ITEM(__pyx_t_1, 6, __pyx_n_s_basic_stats); + __Pyx_INCREF(__pyx_n_s_z_score); + __Pyx_GIVEREF(__pyx_n_s_z_score); + PyList_SET_ITEM(__pyx_t_1, 7, __pyx_n_s_z_score); + __Pyx_INCREF(__pyx_n_s_z_normalize); + __Pyx_GIVEREF(__pyx_n_s_z_normalize); + PyList_SET_ITEM(__pyx_t_1, 8, __pyx_n_s_z_normalize); + __Pyx_INCREF(__pyx_n_s_stdev_z_split); + __Pyx_GIVEREF(__pyx_n_s_stdev_z_split); + PyList_SET_ITEM(__pyx_t_1, 9, __pyx_n_s_stdev_z_split); + __Pyx_INCREF(__pyx_n_s_histo_analysis); + __Pyx_GIVEREF(__pyx_n_s_histo_analysis); + PyList_SET_ITEM(__pyx_t_1, 10, __pyx_n_s_histo_analysis); + __Pyx_INCREF(__pyx_n_s_poly_regression); + __Pyx_GIVEREF(__pyx_n_s_poly_regression); + PyList_SET_ITEM(__pyx_t_1, 11, __pyx_n_s_poly_regression); + __Pyx_INCREF(__pyx_n_s_log_regression); + __Pyx_GIVEREF(__pyx_n_s_log_regression); + PyList_SET_ITEM(__pyx_t_1, 12, __pyx_n_s_log_regression); + __Pyx_INCREF(__pyx_n_s_exp_regression); + __Pyx_GIVEREF(__pyx_n_s_exp_regression); + PyList_SET_ITEM(__pyx_t_1, 13, __pyx_n_s_exp_regression); + __Pyx_INCREF(__pyx_n_s_r_squared); + __Pyx_GIVEREF(__pyx_n_s_r_squared); + PyList_SET_ITEM(__pyx_t_1, 14, __pyx_n_s_r_squared); + __Pyx_INCREF(__pyx_n_s_rms_2); + __Pyx_GIVEREF(__pyx_n_s_rms_2); + PyList_SET_ITEM(__pyx_t_1, 15, __pyx_n_s_rms_2); + __Pyx_INCREF(__pyx_n_s_calc_overfit); + __Pyx_GIVEREF(__pyx_n_s_calc_overfit); + PyList_SET_ITEM(__pyx_t_1, 16, __pyx_n_s_calc_overfit); + __Pyx_INCREF(__pyx_n_s_strip_data); + __Pyx_GIVEREF(__pyx_n_s_strip_data); + PyList_SET_ITEM(__pyx_t_1, 17, __pyx_n_s_strip_data); + __Pyx_INCREF(__pyx_n_s_optimize_regression); + __Pyx_GIVEREF(__pyx_n_s_optimize_regression); + PyList_SET_ITEM(__pyx_t_1, 18, __pyx_n_s_optimize_regression); + __Pyx_INCREF(__pyx_n_s_select_best_regression); + __Pyx_GIVEREF(__pyx_n_s_select_best_regression); + PyList_SET_ITEM(__pyx_t_1, 19, __pyx_n_s_select_best_regression); + __Pyx_INCREF(__pyx_n_s_basic_analysis); + __Pyx_GIVEREF(__pyx_n_s_basic_analysis); + PyList_SET_ITEM(__pyx_t_1, 20, __pyx_n_s_basic_analysis); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_t_1) < 0) __PYX_ERR(0, 106, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":135 + * # imports (now in alphabetical order! v 1.0.3.006): + * + * from bisect import bisect_left, bisect_right # <<<<<<<<<<<<<< + * import collections + * import csv + */ + __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_bisect_left); + __Pyx_GIVEREF(__pyx_n_s_bisect_left); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_bisect_left); + __Pyx_INCREF(__pyx_n_s_bisect_right); + __Pyx_GIVEREF(__pyx_n_s_bisect_right); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_bisect_right); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_bisect, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __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_bisect_left); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_bisect_left, __pyx_t_1) < 0) __PYX_ERR(0, 135, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_bisect_right); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_bisect_right, __pyx_t_1) < 0) __PYX_ERR(0, 135, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":136 + * + * from bisect import bisect_left, bisect_right + * import collections # <<<<<<<<<<<<<< + * import csv + * from decimal import Decimal + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_collections, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_collections, __pyx_t_2) < 0) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":137 + * from bisect import bisect_left, bisect_right + * import collections + * import csv # <<<<<<<<<<<<<< + * from decimal import Decimal + * import functools + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_csv, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_csv, __pyx_t_2) < 0) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":138 + * import collections + * import csv + * from decimal import Decimal # <<<<<<<<<<<<<< + * import functools + * from fractions import Fraction + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_Decimal); + __Pyx_GIVEREF(__pyx_n_s_Decimal); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_Decimal); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_decimal, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 138, __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_Decimal); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Decimal, __pyx_t_2) < 0) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":139 + * import csv + * from decimal import Decimal + * import functools # <<<<<<<<<<<<<< + * from fractions import Fraction + * from itertools import groupby + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_functools, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_functools, __pyx_t_1) < 0) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":140 + * from decimal import Decimal + * import functools + * from fractions import Fraction # <<<<<<<<<<<<<< + * from itertools import groupby + * import math + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_Fraction); + __Pyx_GIVEREF(__pyx_n_s_Fraction); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Fraction); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_fractions, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 140, __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_Fraction); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Fraction, __pyx_t_1) < 0) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":141 + * import functools + * from fractions import Fraction + * from itertools import groupby # <<<<<<<<<<<<<< + * import math + * import matplotlib + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_groupby); + __Pyx_GIVEREF(__pyx_n_s_groupby); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_groupby); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_itertools, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 141, __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_groupby); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_groupby, __pyx_t_2) < 0) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":142 + * from fractions import Fraction + * from itertools import groupby + * import math # <<<<<<<<<<<<<< + * import matplotlib + * import numbers + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_math, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_math, __pyx_t_1) < 0) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":143 + * from itertools import groupby + * import math + * import matplotlib # <<<<<<<<<<<<<< + * import numbers + * import numpy as np + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_matplotlib, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_matplotlib, __pyx_t_1) < 0) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":144 + * import math + * import matplotlib + * import numbers # <<<<<<<<<<<<<< + * import numpy as np + * import pandas + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numbers, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_numbers, __pyx_t_1) < 0) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":145 + * import matplotlib + * import numbers + * import numpy as np # <<<<<<<<<<<<<< + * import pandas + * import random + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":146 + * import numbers + * import numpy as np + * import pandas # <<<<<<<<<<<<<< + * import random + * import scipy + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_pandas, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pandas, __pyx_t_1) < 0) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":147 + * import numpy as np + * import pandas + * import random # <<<<<<<<<<<<<< + * import scipy + * from scipy.optimize import curve_fit + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_random, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_random, __pyx_t_1) < 0) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":148 + * import pandas + * import random + * import scipy # <<<<<<<<<<<<<< + * from scipy.optimize import curve_fit + * from scipy import stats + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_scipy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_scipy, __pyx_t_1) < 0) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":149 + * import random + * import scipy + * from scipy.optimize import curve_fit # <<<<<<<<<<<<<< + * from scipy import stats + * from sklearn import * + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_curve_fit); + __Pyx_GIVEREF(__pyx_n_s_curve_fit); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_curve_fit); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_scipy_optimize, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __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_curve_fit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_curve_fit, __pyx_t_1) < 0) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":150 + * import scipy + * from scipy.optimize import curve_fit + * from scipy import stats # <<<<<<<<<<<<<< + * from sklearn import * + * # import statistics <-- statistics.py functions have been integrated into analysis.py as of v 1.0.3.002 + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_stats); + __Pyx_GIVEREF(__pyx_n_s_stats); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_stats); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_scipy, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __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_stats); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_stats, __pyx_t_2) < 0) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":151 + * from scipy.optimize import curve_fit + * from scipy import stats + * from sklearn import * # <<<<<<<<<<<<<< + * # import statistics <-- statistics.py functions have been integrated into analysis.py as of v 1.0.3.002 + * import time + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s__17); + __Pyx_GIVEREF(__pyx_n_s__17); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s__17); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_sklearn, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_import_star(__pyx_t_2) < 0) __PYX_ERR(0, 151, __pyx_L1_error); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":153 + * from sklearn import * + * # import statistics <-- statistics.py functions have been integrated into analysis.py as of v 1.0.3.002 + * import time # <<<<<<<<<<<<<< + * import torch + * + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_time, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_time, __pyx_t_2) < 0) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":154 + * # import statistics <-- statistics.py functions have been integrated into analysis.py as of v 1.0.3.002 + * import time + * import torch # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_torch, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_torch, __pyx_t_2) < 0) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":157 + * + * + * class error(ValueError): # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__18); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__18, __pyx_n_s_error, __pyx_n_s_error, (PyObject *) NULL, __pyx_n_s_analysis, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_error, __pyx_tuple__18, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_error, __pyx_t_3) < 0) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":161 + * + * + * def _init_device(setting, arg): # initiates computation device for ANNs # <<<<<<<<<<<<<< + * if setting == "cuda": + * try: + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_1_init_device, 0, __pyx_n_s_init_device, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__20)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_init_device, __pyx_t_2) < 0) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":176 + * + * + * class c_entities: # <<<<<<<<<<<<<< + * + * c_names = [] + */ + __pyx_t_2 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_c_entities, __pyx_n_s_c_entities, (PyObject *) NULL, __pyx_n_s_analysis, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "analysis.py":178 + * class c_entities: + * + * c_names = [] # <<<<<<<<<<<<<< + * c_ids = [] + * c_pos = [] + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_names, __pyx_t_1) < 0) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":179 + * + * c_names = [] + * c_ids = [] # <<<<<<<<<<<<<< + * c_pos = [] + * c_properties = [] + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_ids, __pyx_t_1) < 0) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":180 + * c_names = [] + * c_ids = [] + * c_pos = [] # <<<<<<<<<<<<<< + * c_properties = [] + * c_logic = [] + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_pos, __pyx_t_1) < 0) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":181 + * c_ids = [] + * c_pos = [] + * c_properties = [] # <<<<<<<<<<<<<< + * c_logic = [] + * + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_properties, __pyx_t_1) < 0) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":182 + * c_pos = [] + * c_properties = [] + * c_logic = [] # <<<<<<<<<<<<<< + * + * def debug(self): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_logic, __pyx_t_1) < 0) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":184 + * c_logic = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("c_entities has attributes names, ids, positions, properties, and logic. __init__ takes self, 1d array of names, 1d array of ids, 2d array of positions, nd array of properties, and nd array of logic") + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_10c_entities_1debug, 0, __pyx_n_s_c_entities_debug, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_debug, __pyx_t_1) < 0) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":188 + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] + * + * def __init__(self, names, ids, pos, properties, logic): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_10c_entities_3__init__, 0, __pyx_n_s_c_entities___init, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__24)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_init, __pyx_t_1) < 0) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":196 + * return None + * + * def append(self, n_name, n_id, n_pos, n_property, n_logic): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_10c_entities_5append, 0, __pyx_n_s_c_entities_append, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_append, __pyx_t_1) < 0) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":204 + * return None + * + * def edit(self, search, n_name, n_id, n_pos, n_property, n_logic): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_10c_entities_7edit, 0, __pyx_n_s_c_entities_edit, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__28)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_edit, __pyx_t_1) < 0) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":226 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_10c_entities_9search, 0, __pyx_n_s_c_entities_search, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__30)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_search, __pyx_t_1) < 0) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":234 + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_properties[position], self.c_logic[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_logic] + * + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_10c_entities_11regurgitate, 0, __pyx_n_s_c_entities_regurgitate, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__32)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_regurgitate, __pyx_t_1) < 0) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":176 + * + * + * class c_entities: # <<<<<<<<<<<<<< + * + * c_names = [] + */ + __pyx_t_1 = __Pyx_Py3ClassCreate(((PyObject*)&__Pyx_DefaultClassType), __pyx_n_s_c_entities, __pyx_empty_tuple, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_c_entities, __pyx_t_1) < 0) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":238 + * + * + * class nc_entities: # <<<<<<<<<<<<<< + * + * c_names = [] + */ + __pyx_t_2 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_nc_entities, __pyx_n_s_nc_entities, (PyObject *) NULL, __pyx_n_s_analysis, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "analysis.py":240 + * class nc_entities: + * + * c_names = [] # <<<<<<<<<<<<<< + * c_ids = [] + * c_pos = [] + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_names, __pyx_t_1) < 0) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":241 + * + * c_names = [] + * c_ids = [] # <<<<<<<<<<<<<< + * c_pos = [] + * c_properties = [] + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_ids, __pyx_t_1) < 0) __PYX_ERR(0, 241, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":242 + * c_names = [] + * c_ids = [] + * c_pos = [] # <<<<<<<<<<<<<< + * c_properties = [] + * c_effects = [] + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_pos, __pyx_t_1) < 0) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":243 + * c_ids = [] + * c_pos = [] + * c_properties = [] # <<<<<<<<<<<<<< + * c_effects = [] + * + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_properties, __pyx_t_1) < 0) __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":244 + * c_pos = [] + * c_properties = [] + * c_effects = [] # <<<<<<<<<<<<<< + * + * def debug(self): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_effects, __pyx_t_1) < 0) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":246 + * c_effects = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("nc_entities (non-controlable entities) has attributes names, ids, positions, properties, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of positions, 2d array of properties, and 2d array of effects.") + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_11nc_entities_1debug, 0, __pyx_n_s_nc_entities_debug, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_debug, __pyx_t_1) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":250 + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] + * + * def __init__(self, names, ids, pos, properties, effects): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_11nc_entities_3__init__, 0, __pyx_n_s_nc_entities___init, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__36)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_init, __pyx_t_1) < 0) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":258 + * return None + * + * def append(self, n_name, n_id, n_pos, n_property, n_effect): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_11nc_entities_5append, 0, __pyx_n_s_nc_entities_append, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__38)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_append, __pyx_t_1) < 0) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":267 + * return None + * + * def edit(self, search, n_name, n_id, n_pos, n_property, n_effect): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_11nc_entities_7edit, 0, __pyx_n_s_nc_entities_edit, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__40)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_edit, __pyx_t_1) < 0) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":289 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_11nc_entities_9search, 0, __pyx_n_s_nc_entities_search, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__42)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_search, __pyx_t_1) < 0) __PYX_ERR(0, 289, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":297 + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_properties[position], self.c_effects[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * + * return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects] + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_11nc_entities_11regurgitate, 0, __pyx_n_s_nc_entities_regurgitate, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__44)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_regurgitate, __pyx_t_1) < 0) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":238 + * + * + * class nc_entities: # <<<<<<<<<<<<<< + * + * c_names = [] + */ + __pyx_t_1 = __Pyx_Py3ClassCreate(((PyObject*)&__Pyx_DefaultClassType), __pyx_n_s_nc_entities, __pyx_empty_tuple, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_nc_entities, __pyx_t_1) < 0) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":302 + * + * + * class obstacles: # <<<<<<<<<<<<<< + * + * c_names = [] + */ + __pyx_t_2 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_obstacles, __pyx_n_s_obstacles, (PyObject *) NULL, __pyx_n_s_analysis, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "analysis.py":304 + * class obstacles: + * + * c_names = [] # <<<<<<<<<<<<<< + * c_ids = [] + * c_perim = [] + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 304, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_names, __pyx_t_1) < 0) __PYX_ERR(0, 304, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":305 + * + * c_names = [] + * c_ids = [] # <<<<<<<<<<<<<< + * c_perim = [] + * c_effects = [] + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_ids, __pyx_t_1) < 0) __PYX_ERR(0, 305, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":306 + * c_names = [] + * c_ids = [] + * c_perim = [] # <<<<<<<<<<<<<< + * c_effects = [] + * + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_perim, __pyx_t_1) < 0) __PYX_ERR(0, 306, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":307 + * c_ids = [] + * c_perim = [] + * c_effects = [] # <<<<<<<<<<<<<< + * + * def debug(self): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_effects, __pyx_t_1) < 0) __PYX_ERR(0, 307, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":309 + * c_effects = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("obstacles has atributes names, ids, positions, perimeters, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 3d array of perimeters, 2d array of effects.") + * return [self.c_names, self.c_ids, self.c_perim, self.c_effects] + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_9obstacles_1debug, 0, __pyx_n_s_obstacles_debug, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__46)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 309, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_debug, __pyx_t_1) < 0) __PYX_ERR(0, 309, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":313 + * return [self.c_names, self.c_ids, self.c_perim, self.c_effects] + * + * def __init__(self, names, ids, perims, effects): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_9obstacles_3__init__, 0, __pyx_n_s_obstacles___init, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__48)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_init, __pyx_t_1) < 0) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":320 + * return None + * + * def append(self, n_name, n_id, n_perim, n_effect): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_9obstacles_5append, 0, __pyx_n_s_obstacles_append, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__50)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 320, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_append, __pyx_t_1) < 0) __PYX_ERR(0, 320, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":327 + * return None + * + * def edit(self, search, n_name, n_id, n_perim, n_effect): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_9obstacles_7edit, 0, __pyx_n_s_obstacles_edit, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__52)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 327, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_edit, __pyx_t_1) < 0) __PYX_ERR(0, 327, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":347 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_9obstacles_9search, 0, __pyx_n_s_obstacles_search, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__54)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_search, __pyx_t_1) < 0) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":355 + * return [self.c_names[position], self.c_ids[position], self.c_perim[position], self.c_effects[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * return[self.c_names, self.c_ids, self.c_perim, self.c_effects] + * + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_9obstacles_11regurgitate, 0, __pyx_n_s_obstacles_regurgitate, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__56)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_regurgitate, __pyx_t_1) < 0) __PYX_ERR(0, 355, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":302 + * + * + * class obstacles: # <<<<<<<<<<<<<< + * + * c_names = [] + */ + __pyx_t_1 = __Pyx_Py3ClassCreate(((PyObject*)&__Pyx_DefaultClassType), __pyx_n_s_obstacles, __pyx_empty_tuple, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_obstacles, __pyx_t_1) < 0) __PYX_ERR(0, 302, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":359 + * + * + * class objectives: # <<<<<<<<<<<<<< + * + * c_names = [] + */ + __pyx_t_2 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_objectives, __pyx_n_s_objectives, (PyObject *) NULL, __pyx_n_s_analysis, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "analysis.py":361 + * class objectives: + * + * c_names = [] # <<<<<<<<<<<<<< + * c_ids = [] + * c_pos = [] + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_names, __pyx_t_1) < 0) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":362 + * + * c_names = [] + * c_ids = [] # <<<<<<<<<<<<<< + * c_pos = [] + * c_effects = [] + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_ids, __pyx_t_1) < 0) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":363 + * c_names = [] + * c_ids = [] + * c_pos = [] # <<<<<<<<<<<<<< + * c_effects = [] + * + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_pos, __pyx_t_1) < 0) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":364 + * c_ids = [] + * c_pos = [] + * c_effects = [] # <<<<<<<<<<<<<< + * + * def debug(self): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_c_effects, __pyx_t_1) < 0) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":366 + * c_effects = [] + * + * def debug(self): # <<<<<<<<<<<<<< + * print("objectives has atributes names, ids, positions, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 1d array of effects.") + * return [self.c_names, self.c_ids, self.c_pos, self.c_effects] + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_10objectives_1debug, 0, __pyx_n_s_objectives_debug, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__58)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_debug, __pyx_t_1) < 0) __PYX_ERR(0, 366, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":370 + * return [self.c_names, self.c_ids, self.c_pos, self.c_effects] + * + * def __init__(self, names, ids, pos, effects): # <<<<<<<<<<<<<< + * self.c_names = names + * self.c_ids = ids + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_10objectives_3__init__, 0, __pyx_n_s_objectives___init, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__60)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_init, __pyx_t_1) < 0) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":377 + * return None + * + * def append(self, n_name, n_id, n_pos, n_effect): # <<<<<<<<<<<<<< + * self.c_names.append(n_name) + * self.c_ids.append(n_id) + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_10objectives_5append, 0, __pyx_n_s_objectives_append, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__62)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_append, __pyx_t_1) < 0) __PYX_ERR(0, 377, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":384 + * return None + * + * def edit(self, search, n_name, n_id, n_pos, n_effect): # <<<<<<<<<<<<<< + * position = 0 + * print(self.c_ids) + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_10objectives_7edit, 0, __pyx_n_s_objectives_edit, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__64)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_edit, __pyx_t_1) < 0) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":405 + * return None + * + * def search(self, search): # <<<<<<<<<<<<<< + * position = 0 + * for i in range(0, len(self.c_ids), 1): + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_10objectives_9search, 0, __pyx_n_s_objectives_search, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__66)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_search, __pyx_t_1) < 0) __PYX_ERR(0, 405, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":413 + * return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_effects[position]] + * + * def regurgitate(self): # <<<<<<<<<<<<<< + * return[self.c_names, self.c_ids, self.c_pos, self.c_effects] + * + */ + __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_10objectives_11regurgitate, 0, __pyx_n_s_objectives_regurgitate, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__68)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_regurgitate, __pyx_t_1) < 0) __PYX_ERR(0, 413, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "analysis.py":359 + * + * + * class objectives: # <<<<<<<<<<<<<< + * + * c_names = [] + */ + __pyx_t_1 = __Pyx_Py3ClassCreate(((PyObject*)&__Pyx_DefaultClassType), __pyx_n_s_objectives, __pyx_empty_tuple, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_objectives, __pyx_t_1) < 0) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":417 + * + * + * def load_csv(filepath): # <<<<<<<<<<<<<< + * with open(filepath, newline='') as csvfile: + * file_array = list(csv.reader(csvfile)) + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_3load_csv, 0, __pyx_n_s_load_csv, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__70)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 417, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_load_csv, __pyx_t_2) < 0) __PYX_ERR(0, 417, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":425 + * + * # data=array, mode = ['1d':1d_basic_stats, 'column':c_basic_stats, 'row':r_basic_stats], arg for mode 1 or mode 2 for column or row + * def basic_stats(data, method, arg): # <<<<<<<<<<<<<< + * + * if method == 'debug': + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_5basic_stats, 0, __pyx_n_s_basic_stats, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__72)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_basic_stats, __pyx_t_2) < 0) __PYX_ERR(0, 425, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":511 + * + * # returns z score with inputs of point, mean and standard deviation of spread + * def z_score(point, mean, stdev): # <<<<<<<<<<<<<< + * score = (point - mean) / stdev + * return score + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_7z_score, 0, __pyx_n_s_z_score, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__74)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_z_score, __pyx_t_2) < 0) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":517 + * + * # mode is either 'x' or 'y' or 'both' depending on the variable(s) to be normalized + * def z_normalize(x, y, mode): # <<<<<<<<<<<<<< + * + * x_norm = [] + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_9z_normalize, 0, __pyx_n_s_z_normalize, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__76)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 517, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_z_normalize, __pyx_t_2) < 0) __PYX_ERR(0, 517, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":560 + * + * # returns n-th percentile of spread given mean, standard deviation, lower z-score, and upper z-score + * def stdev_z_split(mean, stdev, delta, low_bound, high_bound): # <<<<<<<<<<<<<< + * + * z_split = [] + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_11stdev_z_split, 0, __pyx_n_s_stdev_z_split, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__78)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 560, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_stdev_z_split, __pyx_t_2) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":575 + * + * + * def histo_analysis(hist_data, delta, low_bound, high_bound): # <<<<<<<<<<<<<< + * + * if hist_data == 'debug': + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_13histo_analysis, 0, __pyx_n_s_histo_analysis, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__80)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_histo_analysis, __pyx_t_2) < 0) __PYX_ERR(0, 575, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":613 + * + * + * def poly_regression(x, y, power): # <<<<<<<<<<<<<< + * + * if x == "null": # if x is 'null', then x will be filled with integer points between 1 and the size of y + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_15poly_regression, 0, __pyx_n_s_poly_regression, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__82)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 613, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_poly_regression, __pyx_t_2) < 0) __PYX_ERR(0, 613, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":649 + * + * + * def log_regression(x, y, base): # <<<<<<<<<<<<<< + * + * x_fit = [] + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_17log_regression, 0, __pyx_n_s_log_regression, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__84)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 649, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_log_regression, __pyx_t_2) < 0) __PYX_ERR(0, 649, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":680 + * + * + * def exp_regression(x, y, base): # <<<<<<<<<<<<<< + * + * y_fit = [] + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_19exp_regression, 0, __pyx_n_s_exp_regression, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__86)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 680, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_exp_regression, __pyx_t_2) < 0) __PYX_ERR(0, 680, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":711 + * + * + * def tanh_regression(x, y): # <<<<<<<<<<<<<< + * + * def tanh(x, a, b, c, d): + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_21tanh_regression, 0, __pyx_n_s_tanh_regression, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__88)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 711, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_tanh_regression, __pyx_t_2) < 0) __PYX_ERR(0, 711, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":735 + * + * + * def r_squared(predictions, targets): # assumes equal size inputs # <<<<<<<<<<<<<< + * + * return metrics.r2_score(np.array(targets), np.array(predictions)) + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_23r_squared, 0, __pyx_n_s_r_squared, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__90)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 735, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_r_squared, __pyx_t_2) < 0) __PYX_ERR(0, 735, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":740 + * + * + * def rms(predictions, targets): # assumes equal size inputs # <<<<<<<<<<<<<< + * + * _sum = 0 + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_25rms, 0, __pyx_n_s_rms_2, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__92)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 740, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_rms_2, __pyx_t_2) < 0) __PYX_ERR(0, 740, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":750 + * + * + * def calc_overfit(equation, rms_train, r2_train, x_test, y_test): # <<<<<<<<<<<<<< + * + * # performance overfit = performance(train) - performance(test) where performance is r^2 + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_27calc_overfit, 0, __pyx_n_s_calc_overfit, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__94)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 750, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_calc_overfit, __pyx_t_2) < 0) __PYX_ERR(0, 750, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":769 + * + * + * def strip_data(data, mode): # <<<<<<<<<<<<<< + * + * if mode == "adam": # x is the row number, y are the data + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_29strip_data, 0, __pyx_n_s_strip_data, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__96)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 769, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_strip_data, __pyx_t_2) < 0) __PYX_ERR(0, 769, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":782 + * + * # _range in poly regression is the range of powers tried, and in log/exp it is the inverse of the stepsize taken from -1000 to 1000 + * def optimize_regression(x, y, _range, resolution): # <<<<<<<<<<<<<< + * # usage not: for demonstration purpose only, performance is shit + * if type(resolution) != int: + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_31optimize_regression, 0, __pyx_n_s_optimize_regression, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__98)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_optimize_regression, __pyx_t_2) < 0) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":872 + * + * + * def select_best_regression(eqs, rmss, r2s, overfit, selector): # <<<<<<<<<<<<<< + * + * b_eq = "" + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_33select_best_regression, 0, __pyx_n_s_select_best_regression, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__100)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 872, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_select_best_regression, __pyx_t_2) < 0) __PYX_ERR(0, 872, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":901 + * + * + * def p_value(x, y): # takes 2 1d arrays # <<<<<<<<<<<<<< + * + * return stats.ttest_ind(x, y)[1] + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_35p_value, 0, __pyx_n_s_p_value, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__102)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 901, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_p_value, __pyx_t_2) < 0) __PYX_ERR(0, 901, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":907 + * + * # assumes that rows are the independent variable and columns are the dependant. also assumes that time flows from lowest column to highest column. + * def basic_analysis(data): # <<<<<<<<<<<<<< + * + * row = len(data) + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_37basic_analysis, 0, __pyx_n_s_basic_analysis, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__104)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 907, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_basic_analysis, __pyx_t_2) < 0) __PYX_ERR(0, 907, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":931 + * + * + * def benchmark(x, y): # <<<<<<<<<<<<<< + * + * start_g = time.time() + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_39benchmark, 0, __pyx_n_s_benchmark, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__106)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 931, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_benchmark, __pyx_t_2) < 0) __PYX_ERR(0, 931, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":944 + * + * + * def generate_data(filename, x, y, low, high): # <<<<<<<<<<<<<< + * + * file = open(filename, "w") + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_41generate_data, 0, __pyx_n_s_generate_data, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__108)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_generate_data, __pyx_t_2) < 0) __PYX_ERR(0, 944, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":958 + * + * + * class StatisticsError(ValueError): # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__109); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 958, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__109, __pyx_n_s_StatisticsError, __pyx_n_s_StatisticsError, (PyObject *) NULL, __pyx_n_s_analysis, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 958, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_StatisticsError, __pyx_tuple__109, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 958, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_StatisticsError, __pyx_t_3) < 0) __PYX_ERR(0, 958, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":962 + * + * + * def _sum(data, start=0): # <<<<<<<<<<<<<< + * count = 0 + * n, d = _exact_ratio(start) + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_43_sum, 0, __pyx_n_s_sum_2, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__111)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__112); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_sum_2, __pyx_t_2) < 0) __PYX_ERR(0, 962, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":983 + * + * + * def _isfinite(x): # <<<<<<<<<<<<<< + * try: + * return x.is_finite() # Likely a Decimal. + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_45_isfinite, 0, __pyx_n_s_isfinite, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__114)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_isfinite, __pyx_t_2) < 0) __PYX_ERR(0, 983, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":990 + * + * + * def _coerce(T, S): # <<<<<<<<<<<<<< + * + * assert T is not bool, "initial type T is bool" + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_47_coerce, 0, __pyx_n_s_coerce, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__116)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 990, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_coerce, __pyx_t_2) < 0) __PYX_ERR(0, 990, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":1021 + * + * + * def _exact_ratio(x): # <<<<<<<<<<<<<< + * + * try: + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_49_exact_ratio, 0, __pyx_n_s_exact_ratio, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__118)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_exact_ratio, __pyx_t_2) < 0) __PYX_ERR(0, 1021, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":1045 + * + * + * def _convert(value, T): # <<<<<<<<<<<<<< + * + * if type(value) is T: + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_51_convert, 0, __pyx_n_s_convert, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__120)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_convert, __pyx_t_2) < 0) __PYX_ERR(0, 1045, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":1062 + * + * + * def _counts(data): # <<<<<<<<<<<<<< + * + * table = collections.Counter(iter(data)).most_common() + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_53_counts, 0, __pyx_n_s_counts, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__122)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1062, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_counts, __pyx_t_2) < 0) __PYX_ERR(0, 1062, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":1076 + * + * + * def _find_lteq(a, x): # <<<<<<<<<<<<<< + * + * i = bisect_left(a, x) + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_55_find_lteq, 0, __pyx_n_s_find_lteq, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__124)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1076, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_find_lteq, __pyx_t_2) < 0) __PYX_ERR(0, 1076, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":1084 + * + * + * def _find_rteq(a, l, x): # <<<<<<<<<<<<<< + * + * i = bisect_right(a, x, lo=l) + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_57_find_rteq, 0, __pyx_n_s_find_rteq, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__126)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1084, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_find_rteq, __pyx_t_2) < 0) __PYX_ERR(0, 1084, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":1092 + * + * + * def _fail_neg(values, errmsg='negative value'): # <<<<<<<<<<<<<< + * + * for x in values: + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_59_fail_neg, 0, __pyx_n_s_fail_neg, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__16)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1092, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__128); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_fail_neg, __pyx_t_2) < 0) __PYX_ERR(0, 1092, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":1100 + * + * + * def mean(data): # <<<<<<<<<<<<<< + * + * if iter(data) is data: + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_62mean, 0, __pyx_n_s_mean, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__130)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_mean, __pyx_t_2) < 0) __PYX_ERR(0, 1100, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":1112 + * + * + * def median(data): # <<<<<<<<<<<<<< + * + * data = sorted(data) + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_64median, 0, __pyx_n_s_median, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__132)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_median, __pyx_t_2) < 0) __PYX_ERR(0, 1112, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":1125 + * + * + * def mode(data): # <<<<<<<<<<<<<< + * + * table = _counts(data) + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_66mode, 0, __pyx_n_s_mode, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__134)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_mode, __pyx_t_2) < 0) __PYX_ERR(0, 1125, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":1138 + * + * + * def _ss(data, c=None): # <<<<<<<<<<<<<< + * + * if c is None: + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_68_ss, 0, __pyx_n_s_ss, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__136)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__137); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ss, __pyx_t_2) < 0) __PYX_ERR(0, 1138, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":1151 + * + * + * def variance(data, xbar=None): # <<<<<<<<<<<<<< + * + * if iter(data) is data: + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_70variance, 0, __pyx_n_s_variance, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__139)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__140); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_variance, __pyx_t_2) < 0) __PYX_ERR(0, 1151, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":1162 + * + * + * def stdev(data, xbar=None): # <<<<<<<<<<<<<< + * + * var = variance(data, xbar) + */ + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_8analysis_72stdev, 0, __pyx_n_s_stdev, NULL, __pyx_n_s_analysis, __pyx_d, ((PyObject *)__pyx_codeobj__142)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__143); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_stdev, __pyx_t_2) < 0) __PYX_ERR(0, 1162, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "analysis.py":1 + * # Titan Robotics Team 2022: Data Analysis Module # <<<<<<<<<<<<<< + * # Written by Arthur Lu & Jacob Levine + * # Notes: + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init analysis", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init analysis"); + } + __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 +} + +/* --- 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; +} + +/* 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); +} + +/* 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_CheckExact(key)) || 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 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(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 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(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; +} + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* 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); +} + +/* 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, int 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, nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, 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 = func->ob_type->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 (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + 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 + +/* 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; +} + +/* 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 + +/* 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; +} + +/* 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 + +/* 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 + +/* 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 + +/* 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)); +} + +/* SetItemInt */ +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { + int r; + if (!j) return -1; + r = PyObject_SetItem(o, j, v); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, 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) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { + PyObject* old = PyList_GET_ITEM(o, n); + Py_INCREF(v); + PyList_SET_ITEM(o, n, v); + Py_DECREF(old); + return 1; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_ass_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 -1; + PyErr_Clear(); + } + } + return m->sq_ass_item(o, i, v); + } + } +#else +#if CYTHON_COMPILING_IN_PYPY + if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) +#else + if (is_list || PySequence_Check(o)) +#endif + { + return PySequence_SetItem(o, i, v); + } +#endif + return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); +} + +/* None */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/* PyIntCompare */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) { + if (op1 == op2) { + Py_RETURN_TRUE; + } + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long a = PyInt_AS_LONG(op1); + if (a == b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + int unequal; + unsigned long uintval; + Py_ssize_t size = Py_SIZE(op1); + const digit* digits = ((PyLongObject*)op1)->ob_digit; + if (intval == 0) { + if (size == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } else if (intval < 0) { + if (size >= 0) + Py_RETURN_FALSE; + intval = -intval; + size = -size; + } else { + if (size <= 0) + Py_RETURN_FALSE; + } + uintval = (unsigned long) intval; +#if PyLong_SHIFT * 4 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 4)) { + unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 3 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 3)) { + unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 2 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 2)) { + unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 1 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 1)) { + unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif + unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); + if (unequal == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + if ((double)a == (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + return ( + PyObject_RichCompare(op1, op2, Py_EQ)); +} + +/* ObjectGetItem */ +#if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { + PyObject *runerr; + Py_ssize_t key_value; + PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; + if (unlikely(!(m && m->sq_item))) { + PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); + return NULL; + } + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); + } + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); + } + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { + PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; + if (likely(m && m->mp_subscript)) { + return m->mp_subscript(obj, key); + } + return __Pyx_PyObject_GetIndex(obj, key); +} +#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; +} + +/* pyobject_as_double */ +static double __Pyx__PyObject_AsDouble(PyObject* obj) { + PyObject* float_value; +#if !CYTHON_USE_TYPE_SLOTS + float_value = PyNumber_Float(obj); if ((0)) goto bad; +#else + PyNumberMethods *nb = Py_TYPE(obj)->tp_as_number; + if (likely(nb) && likely(nb->nb_float)) { + float_value = nb->nb_float(obj); + if (likely(float_value) && unlikely(!PyFloat_Check(float_value))) { + PyErr_Format(PyExc_TypeError, + "__float__ returned non-float (type %.200s)", + Py_TYPE(float_value)->tp_name); + Py_DECREF(float_value); + goto bad; + } + } else if (PyUnicode_CheckExact(obj) || PyBytes_CheckExact(obj)) { +#if PY_MAJOR_VERSION >= 3 + float_value = PyFloat_FromString(obj); +#else + float_value = PyFloat_FromString(obj, 0); +#endif + } else { + PyObject* args = PyTuple_New(1); + if (unlikely(!args)) goto bad; + PyTuple_SET_ITEM(args, 0, obj); + float_value = PyObject_Call((PyObject*)&PyFloat_Type, args, 0); + PyTuple_SET_ITEM(args, 0, 0); + Py_DECREF(args); + } +#endif + if (likely(float_value)) { + double value = PyFloat_AS_DOUBLE(float_value); + Py_DECREF(float_value); + return value; + } +bad: + return (double)-1; +} + +/* PyIntBinop */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { + (void)inplace; + (void)zerodivision_check; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a - b); + if (likely((x^a) >= 0 || (x^~b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + } + x = a - b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla - llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("subtract", return NULL) + result = ((double)a) - (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); +} +#endif + +/* SliceObject */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, + Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, + int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { +#if CYTHON_USE_TYPE_SLOTS + PyMappingMethods* mp; +#if PY_MAJOR_VERSION < 3 + PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; + if (likely(ms && ms->sq_slice)) { + if (!has_cstart) { + if (_py_start && (*_py_start != Py_None)) { + cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); + if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; + } else + cstart = 0; + } + if (!has_cstop) { + if (_py_stop && (*_py_stop != Py_None)) { + cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); + if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; + } else + cstop = PY_SSIZE_T_MAX; + } + if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { + Py_ssize_t l = ms->sq_length(obj); + if (likely(l >= 0)) { + if (cstop < 0) { + cstop += l; + if (cstop < 0) cstop = 0; + } + if (cstart < 0) { + cstart += l; + if (cstart < 0) cstart = 0; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + goto bad; + PyErr_Clear(); + } + } + return ms->sq_slice(obj, cstart, cstop); + } +#endif + mp = Py_TYPE(obj)->tp_as_mapping; + if (likely(mp && mp->mp_subscript)) +#endif + { + PyObject* result; + PyObject *py_slice, *py_start, *py_stop; + if (_py_slice) { + py_slice = *_py_slice; + } else { + PyObject* owned_start = NULL; + PyObject* owned_stop = NULL; + if (_py_start) { + py_start = *_py_start; + } else { + if (has_cstart) { + owned_start = py_start = PyInt_FromSsize_t(cstart); + if (unlikely(!py_start)) goto bad; + } else + py_start = Py_None; + } + if (_py_stop) { + py_stop = *_py_stop; + } else { + if (has_cstop) { + owned_stop = py_stop = PyInt_FromSsize_t(cstop); + if (unlikely(!py_stop)) { + Py_XDECREF(owned_start); + goto bad; + } + } else + py_stop = Py_None; + } + py_slice = PySlice_New(py_start, py_stop, Py_None); + Py_XDECREF(owned_start); + Py_XDECREF(owned_stop); + if (unlikely(!py_slice)) goto bad; + } +#if CYTHON_USE_TYPE_SLOTS + result = mp->mp_subscript(obj, py_slice); +#else + result = PyObject_GetItem(obj, py_slice); +#endif + if (!_py_slice) { + Py_DECREF(py_slice); + } + return result; + } + PyErr_Format(PyExc_TypeError, + "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); +bad: + return NULL; +} + +/* PyIntBinop */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { + (void)inplace; + (void)zerodivision_check; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a + b); + if (likely((x^a) >= 0 || (x^b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + } + x = a + b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#endif + +/* FetchCommonType */ +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* fake_module; + PyTypeObject* cached_type = NULL; + fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); + if (!fake_module) return NULL; + Py_INCREF(fake_module); + cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); + if (cached_type) { + if (!PyType_Check((PyObject*)cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", + type->tp_name); + goto bad; + } + if (cached_type->tp_basicsize != type->tp_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + type->tp_name); + goto bad; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; + } +done: + Py_DECREF(fake_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +/* CythonFunction */ +#include +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) +{ + if (unlikely(op->func_doc == NULL)) { + if (op->func.m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) +{ + PyObject *tmp = op->func_doc; + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + op->func_doc = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) +{ + if (unlikely(op->func_name == NULL)) { +#if PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = op->func_name; + Py_INCREF(value); + op->func_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) +{ + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = op->func_qualname; + Py_INCREF(value); + op->func_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) +{ + PyObject *self; + self = m->func_closure; + if (self == NULL) + self = Py_None; + Py_INCREF(self); + return self; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) +{ + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) +{ + PyObject *tmp; + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + tmp = op->func_dict; + Py_INCREF(value); + op->func_dict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) +{ + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) +{ + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyTuple_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_tuple; + op->defaults_tuple = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_kwdict; + op->defaults_kwdict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { + PyObject* tmp; + if (!value || value == Py_None) { + value = NULL; + } else if (!PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + tmp = op->func_annotations; + op->func_annotations = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), PY_WRITE_RESTRICTED, 0}, + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromString(m->func.m_ml->ml_name); +#else + return PyString_FromString(m->func.m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type); + if (op == NULL) + return NULL; + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; + op->func.m_ml = ml; + op->func.m_self = (PyObject *) op; + Py_XINCREF(closure); + op->func_closure = closure; + Py_XINCREF(module); + op->func.m_module = module; + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; + op->func_classobj = NULL; + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + PyObject_GC_Track(op); + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); + Py_CLEAR(m->func.m_module); + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); + Py_CLEAR(m->func_classobj); + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + PyObject_GC_Del(m); +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); + Py_VISIT(m->func.m_module); + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); + Py_VISIT(m->func_classobj); + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) +{ + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { + Py_INCREF(func); + return func; + } + if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { + if (type == NULL) + type = (PyObject *)(Py_TYPE(obj)); + return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); + } + if (obj == Py_None) + obj = NULL; + return __Pyx_PyMethod_New(func, obj, type); +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + Py_ssize_t size; + switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 0)) + return (*meth)(self, NULL); + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags in " + "__Pyx_CyFunction_Call. METH_OLDARGS is no " + "longer supported!"); + return NULL; + } + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw); +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; + argc = PyTuple_GET_SIZE(args); + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, + 0, + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_CyFunction_descr_get, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +}; +static int __pyx_CyFunction_init(void) { + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); + if (unlikely(__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* pop_index */ +static PyObject* __Pyx__PyObject_PopNewIndex(PyObject* L, PyObject* py_ix) { + PyObject *r; + if (unlikely(!py_ix)) return NULL; + r = __Pyx__PyObject_PopIndex(L, py_ix); + Py_DECREF(py_ix); + return r; +} +static PyObject* __Pyx__PyObject_PopIndex(PyObject* L, PyObject* py_ix) { + return __Pyx_PyObject_CallMethod1(L, __pyx_n_s_pop, py_ix); +} +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static PyObject* __Pyx__PyList_PopIndex(PyObject* L, PyObject* py_ix, Py_ssize_t ix) { + Py_ssize_t size = PyList_GET_SIZE(L); + if (likely(size > (((PyListObject*)L)->allocated >> 1))) { + Py_ssize_t cix = ix; + if (cix < 0) { + cix += size; + } + if (likely(__Pyx_is_valid_index(cix, size))) { + PyObject* v = PyList_GET_ITEM(L, cix); + Py_SIZE(L) -= 1; + size -= 1; + memmove(&PyList_GET_ITEM(L, cix), &PyList_GET_ITEM(L, cix+1), (size_t)(size-cix)*sizeof(PyObject*)); + return v; + } + } + if (py_ix == Py_None) { + return __Pyx__PyObject_PopNewIndex(L, PyInt_FromSsize_t(ix)); + } else { + return __Pyx__PyObject_PopIndex(L, py_ix); + } +} +#endif + +/* UnpackUnboundCMethod */ +static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { + PyObject *method; + method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); + if (unlikely(!method)) + return -1; + target->method = method; +#if CYTHON_COMPILING_IN_CPYTHON + #if PY_MAJOR_VERSION >= 3 + if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) + #endif + { + PyMethodDescrObject *descr = (PyMethodDescrObject*) method; + target->func = descr->d_method->ml_meth; + target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); + } +#endif + return 0; +} + +/* CallUnboundCMethod1 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg) { + if (likely(cfunc->func)) { + int flag = cfunc->flag; + if (flag == METH_O) { + return (*(cfunc->func))(self, arg); + } else if (PY_VERSION_HEX >= 0x030600B1 && flag == METH_FASTCALL) { + if (PY_VERSION_HEX >= 0x030700A0) { + return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, &arg, 1); + } else { + return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL); + } + } else if (PY_VERSION_HEX >= 0x030700A0 && flag == (METH_FASTCALL | METH_KEYWORDS)) { + return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL); + } + } + return __Pyx__CallUnboundCMethod1(cfunc, self, arg); +} +#endif +static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg){ + PyObject *args, *result = NULL; + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + args = PyTuple_New(1); + if (unlikely(!args)) goto bad; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + if (cfunc->flag & METH_KEYWORDS) + result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL); + else + result = (*cfunc->func)(self, args); + } else { + args = PyTuple_New(2); + if (unlikely(!args)) goto bad; + Py_INCREF(self); + PyTuple_SET_ITEM(args, 0, self); + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 1, arg); + result = __Pyx_PyObject_Call(cfunc->method, args, NULL); + } +#else + args = PyTuple_Pack(2, self, arg); + if (unlikely(!args)) goto bad; + result = __Pyx_PyObject_Call(cfunc->method, args, NULL); +#endif +bad: + Py_XDECREF(args); + return result; +} + +/* CallUnboundCMethod0 */ +static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { + PyObject *args, *result = NULL; + if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_ASSUME_SAFE_MACROS + args = PyTuple_New(1); + if (unlikely(!args)) goto bad; + Py_INCREF(self); + PyTuple_SET_ITEM(args, 0, self); +#else + args = PyTuple_Pack(1, self); + if (unlikely(!args)) goto bad; +#endif + result = __Pyx_PyObject_Call(cfunc->method, args, NULL); + Py_DECREF(args); +bad: + return result; +} + +/* py_dict_items */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) { + if (PY_MAJOR_VERSION >= 3) + return __Pyx_CallUnboundCMethod0(&__pyx_umethod_PyDict_Type_items, d); + else + return PyDict_Items(d); +} + +/* None */ +static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname) { + PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname); +} + +/* CallUnboundCMethod2 */ +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030600B1 +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { + if (likely(cfunc->func)) { + PyObject *args[2] = {arg1, arg2}; + if (cfunc->flag == METH_FASTCALL) { + #if PY_VERSION_HEX >= 0x030700A0 + return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, args, 2); + #else + return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, 2, NULL); + #endif + } + #if PY_VERSION_HEX >= 0x030700A0 + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, 2, NULL); + #endif + } + return __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); +} +#endif +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ + PyObject *args, *result = NULL; + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + args = PyTuple_New(2); + if (unlikely(!args)) goto bad; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + if (cfunc->flag & METH_KEYWORDS) + result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL); + else + result = (*cfunc->func)(self, args); + } else { + args = PyTuple_New(3); + if (unlikely(!args)) goto bad; + Py_INCREF(self); + PyTuple_SET_ITEM(args, 0, self); + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 1, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 2, arg2); + result = __Pyx_PyObject_Call(cfunc->method, args, NULL); + } +#else + args = PyTuple_Pack(3, self, arg1, arg2); + if (unlikely(!args)) goto bad; + result = __Pyx_PyObject_Call(cfunc->method, args, NULL); +#endif +bad: + Py_XDECREF(args); + return result; +} + +/* dict_getitem_default */ +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) { + PyObject* value; +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (unlikely(PyErr_Occurred())) + return NULL; + value = default_value; + } + Py_INCREF(value); + if ((1)); +#else + if (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_CheckExact(key)) { + value = PyDict_GetItem(d, key); + if (unlikely(!value)) { + value = default_value; + } + Py_INCREF(value); + } +#endif + else { + if (default_value == Py_None) + value = __Pyx_CallUnboundCMethod1(&__pyx_umethod_PyDict_Type_get, d, key); + else + value = __Pyx_CallUnboundCMethod2(&__pyx_umethod_PyDict_Type_get, d, key, default_value); + } + return value; +} + +/* DictGetItem */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + if (unlikely(PyTuple_Check(key))) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); + } + } else { + PyErr_SetObject(PyExc_KeyError, key); + } + } + return NULL; + } + Py_INCREF(value); + return value; +} +#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; icurexc_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 + +/* PyIntCompare */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_NeObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) { + if (op1 == op2) { + Py_RETURN_FALSE; + } + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long a = PyInt_AS_LONG(op1); + if (a != b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + int unequal; + unsigned long uintval; + Py_ssize_t size = Py_SIZE(op1); + const digit* digits = ((PyLongObject*)op1)->ob_digit; + if (intval == 0) { + if (size != 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } else if (intval < 0) { + if (size >= 0) + Py_RETURN_TRUE; + intval = -intval; + size = -size; + } else { + if (size <= 0) + Py_RETURN_TRUE; + } + uintval = (unsigned long) intval; +#if PyLong_SHIFT * 4 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 4)) { + unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 3 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 3)) { + unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 2 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 2)) { + unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 1 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 1)) { + unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif + unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); + if (unequal != 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + if ((double)a != (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + return ( + PyObject_RichCompare(op1, op2, Py_NE)); +} + +/* PyIntBinop */ +#if !CYTHON_COMPILING_IN_PYPY +#if PY_MAJOR_VERSION < 3 || CYTHON_USE_PYLONG_INTERNALS +#define __Pyx_PyInt_RemainderObjC_ZeroDivisionError(operand)\ + if (unlikely(zerodivision_check && ((operand) == 0))) {\ + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");\ + return NULL;\ + } +#endif +static PyObject* __Pyx_PyInt_RemainderObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { + (void)inplace; + (void)zerodivision_check; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + __Pyx_PyInt_RemainderObjC_ZeroDivisionError(b) + x = a % b; + x += ((x != 0) & ((x ^ b) < 0)) * b; + return PyInt_FromLong(x); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_remainder(op1, op2); + } + } + __Pyx_PyInt_RemainderObjC_ZeroDivisionError(b) + x = a % b; + x += ((x != 0) & ((x ^ b) < 0)) * b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla % llb; + llx += ((llx != 0) & ((llx ^ llb) < 0)) * llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + return (inplace ? PyNumber_InPlaceRemainder : PyNumber_Remainder)(op1, op2); +} +#endif + +/* PyIntBinop */ +#if !CYTHON_COMPILING_IN_PYPY +#if PY_MAJOR_VERSION < 3 || CYTHON_USE_PYLONG_INTERNALS +#define __Pyx_PyInt_FloorDivideObjC_ZeroDivisionError(operand)\ + if (unlikely(zerodivision_check && ((operand) == 0))) {\ + PyErr_SetString(PyExc_ZeroDivisionError, "integer division by zero");\ + return NULL;\ + } +#endif +static PyObject* __Pyx_PyInt_FloorDivideObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { + (void)inplace; + (void)zerodivision_check; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + __Pyx_PyInt_FloorDivideObjC_ZeroDivisionError(b) + if (unlikely(b == -1 && ((unsigned long)a) == 0-(unsigned long)a)) + return PyInt_Type.tp_as_number->nb_floor_divide(op1, op2); + else { + long q, r; + q = a / b; + r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + x = q; + } + return PyInt_FromLong(x); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_floor_divide(op1, op2); + } + } + __Pyx_PyInt_FloorDivideObjC_ZeroDivisionError(b) + { + long q, r; + q = a / b; + r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + x = q; + } + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + { + PY_LONG_LONG q, r; + q = lla / llb; + r = lla - q*llb; + q -= ((r != 0) & ((r ^ llb) < 0)); + llx = q; + } + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + return (inplace ? PyNumber_InPlaceFloorDivide : PyNumber_FloorDivide)(op1, op2); +} +#endif + +/* 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 + +/* 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 (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; +} + +/* 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; +} + +/* CLineInTraceback */ +#ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(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; + 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" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + 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); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + 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; + 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) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __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); +} + +/* Print */ +#if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION < 3 +static PyObject *__Pyx_GetStdout(void) { + PyObject *f = PySys_GetObject((char *)"stdout"); + if (!f) { + PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout"); + } + return f; +} +static int __Pyx_Print(PyObject* f, PyObject *arg_tuple, int newline) { + int i; + if (!f) { + if (!(f = __Pyx_GetStdout())) + return -1; + } + Py_INCREF(f); + for (i=0; i < PyTuple_GET_SIZE(arg_tuple); i++) { + PyObject* v; + if (PyFile_SoftSpace(f, 1)) { + if (PyFile_WriteString(" ", f) < 0) + goto error; + } + v = PyTuple_GET_ITEM(arg_tuple, i); + if (PyFile_WriteObject(v, f, Py_PRINT_RAW) < 0) + goto error; + if (PyString_Check(v)) { + char *s = PyString_AsString(v); + Py_ssize_t len = PyString_Size(v); + if (len > 0) { + switch (s[len-1]) { + case ' ': break; + case '\f': case '\r': case '\n': case '\t': case '\v': + PyFile_SoftSpace(f, 0); + break; + default: break; + } + } + } + } + if (newline) { + if (PyFile_WriteString("\n", f) < 0) + goto error; + PyFile_SoftSpace(f, 0); + } + Py_DECREF(f); + return 0; +error: + Py_DECREF(f); + return -1; +} +#else +static int __Pyx_Print(PyObject* stream, PyObject *arg_tuple, int newline) { + PyObject* kwargs = 0; + PyObject* result = 0; + PyObject* end_string; + if (unlikely(!__pyx_print)) { + __pyx_print = PyObject_GetAttr(__pyx_b, __pyx_n_s_print); + if (!__pyx_print) + return -1; + } + if (stream) { + kwargs = PyDict_New(); + if (unlikely(!kwargs)) + return -1; + if (unlikely(PyDict_SetItem(kwargs, __pyx_n_s_file, stream) < 0)) + goto bad; + if (!newline) { + end_string = PyUnicode_FromStringAndSize(" ", 1); + if (unlikely(!end_string)) + goto bad; + if (PyDict_SetItem(kwargs, __pyx_n_s_end, end_string) < 0) { + Py_DECREF(end_string); + goto bad; + } + Py_DECREF(end_string); + } + } else if (!newline) { + if (unlikely(!__pyx_print_kwargs)) { + __pyx_print_kwargs = PyDict_New(); + if (unlikely(!__pyx_print_kwargs)) + return -1; + end_string = PyUnicode_FromStringAndSize(" ", 1); + if (unlikely(!end_string)) + return -1; + if (PyDict_SetItem(__pyx_print_kwargs, __pyx_n_s_end, end_string) < 0) { + Py_DECREF(end_string); + return -1; + } + Py_DECREF(end_string); + } + kwargs = __pyx_print_kwargs; + } + result = PyObject_Call(__pyx_print, arg_tuple, kwargs); + if (unlikely(kwargs) && (kwargs != __pyx_print_kwargs)) + Py_DECREF(kwargs); + if (!result) + return -1; + Py_DECREF(result); + return 0; +bad: + if (kwargs != __pyx_print_kwargs) + Py_XDECREF(kwargs); + return -1; +} +#endif + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + 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); + } +} + +/* PyExec */ +static CYTHON_INLINE PyObject* __Pyx_PyExec2(PyObject* o, PyObject* globals) { + return __Pyx_PyExec3(o, globals, NULL); +} +static PyObject* __Pyx_PyExec3(PyObject* o, PyObject* globals, PyObject* locals) { + PyObject* result; + PyObject* s = 0; + char *code = 0; + if (!globals || globals == Py_None) { + globals = __pyx_d; + } else if (!PyDict_Check(globals)) { + PyErr_Format(PyExc_TypeError, "exec() arg 2 must be a dict, not %.200s", + Py_TYPE(globals)->tp_name); + goto bad; + } + if (!locals || locals == Py_None) { + locals = globals; + } + if (__Pyx_PyDict_GetItemStr(globals, __pyx_n_s_builtins) == NULL) { + if (PyDict_SetItem(globals, __pyx_n_s_builtins, PyEval_GetBuiltins()) < 0) + goto bad; + } + if (PyCode_Check(o)) { + if (__Pyx_PyCode_HasFreeVars((PyCodeObject *)o)) { + PyErr_SetString(PyExc_TypeError, + "code object passed to exec() may not contain free variables"); + goto bad; + } + #if CYTHON_COMPILING_IN_PYPY || PY_VERSION_HEX < 0x030200B1 + result = PyEval_EvalCode((PyCodeObject *)o, globals, locals); + #else + result = PyEval_EvalCode(o, globals, locals); + #endif + } else { + PyCompilerFlags cf; + cf.cf_flags = 0; + if (PyUnicode_Check(o)) { + cf.cf_flags = PyCF_SOURCE_IS_UTF8; + s = PyUnicode_AsUTF8String(o); + if (!s) goto bad; + o = s; + #if PY_MAJOR_VERSION >= 3 + } else if (!PyBytes_Check(o)) { + #else + } else if (!PyString_Check(o)) { + #endif + PyErr_Format(PyExc_TypeError, + "exec: arg 1 must be string, bytes or code object, got %.200s", + Py_TYPE(o)->tp_name); + goto bad; + } + #if PY_MAJOR_VERSION >= 3 + code = PyBytes_AS_STRING(o); + #else + code = PyString_AS_STRING(o); + #endif + if (PyEval_MergeCompilerFlags(&cf)) { + result = PyRun_StringFlags(code, Py_file_input, globals, locals, &cf); + } else { + result = PyRun_String(code, Py_file_input, globals, locals); + } + Py_XDECREF(s); + } + return result; +bad: + Py_XDECREF(s); + return 0; +} + +/* PrintOne */ +#if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION < 3 +static int __Pyx_PrintOne(PyObject* f, PyObject *o) { + if (!f) { + if (!(f = __Pyx_GetStdout())) + return -1; + } + Py_INCREF(f); + if (PyFile_SoftSpace(f, 0)) { + if (PyFile_WriteString(" ", f) < 0) + goto error; + } + if (PyFile_WriteObject(o, f, Py_PRINT_RAW) < 0) + goto error; + if (PyFile_WriteString("\n", f) < 0) + goto error; + Py_DECREF(f); + return 0; +error: + Py_DECREF(f); + return -1; + /* the line below is just to avoid C compiler + * warnings about unused functions */ + return __Pyx_Print(f, NULL, 0); +} +#else +static int __Pyx_PrintOne(PyObject* stream, PyObject *o) { + int res; + PyObject* arg_tuple = PyTuple_Pack(1, o); + if (unlikely(!arg_tuple)) + return -1; + res = __Pyx_Print(stream, arg_tuple, 1); + Py_DECREF(arg_tuple); + return res; +} +#endif + +/* GetAttr */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +#if CYTHON_USE_TYPE_SLOTS +#if PY_MAJOR_VERSION >= 3 + if (likely(PyUnicode_Check(n))) +#else + if (likely(PyString_Check(n))) +#endif + return __Pyx_PyObject_GetAttrStr(o, n); +#endif + return PyObject_GetAttr(o, n); +} + +/* Globals */ +static PyObject* __Pyx_Globals(void) { + Py_ssize_t i; + PyObject *names; + PyObject *globals = __pyx_d; + Py_INCREF(globals); + names = PyObject_Dir(__pyx_m); + if (!names) + goto bad; + for (i = PyList_GET_SIZE(names)-1; i >= 0; i--) { +#if CYTHON_COMPILING_IN_PYPY + PyObject* name = PySequence_ITEM(names, i); + if (!name) + goto bad; +#else + PyObject* name = PyList_GET_ITEM(names, i); +#endif + if (!PyDict_Contains(globals, name)) { + PyObject* value = __Pyx_GetAttr(__pyx_m, name); + if (!value) { +#if CYTHON_COMPILING_IN_PYPY + Py_DECREF(name); +#endif + goto bad; + } + if (PyDict_SetItem(globals, name, value) < 0) { +#if CYTHON_COMPILING_IN_PYPY + Py_DECREF(name); +#endif + Py_DECREF(value); + goto bad; + } + } +#if CYTHON_COMPILING_IN_PYPY + Py_DECREF(name); +#endif + } + Py_DECREF(names); + return globals; +bad: + Py_XDECREF(names); + Py_XDECREF(globals); + return NULL; +} + +/* 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;\ + } + +/* CIntFromPy */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + 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; +} + +/* CIntFromPy */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + 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; +} + +/* 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; iexc_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 + +/* CoroutineBase */ +#include +#include +#define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom) +static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject **pvalue) { + PyObject *et, *ev, *tb; + PyObject *value = NULL; + __Pyx_ErrFetch(&et, &ev, &tb); + if (!et) { + Py_XDECREF(tb); + Py_XDECREF(ev); + Py_INCREF(Py_None); + *pvalue = Py_None; + return 0; + } + if (likely(et == PyExc_StopIteration)) { + if (!ev) { + Py_INCREF(Py_None); + value = Py_None; + } +#if PY_VERSION_HEX >= 0x030300A0 + else if (Py_TYPE(ev) == (PyTypeObject*)PyExc_StopIteration) { + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + Py_DECREF(ev); + } +#endif + else if (unlikely(PyTuple_Check(ev))) { + if (PyTuple_GET_SIZE(ev) >= 1) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + value = PyTuple_GET_ITEM(ev, 0); + Py_INCREF(value); +#else + value = PySequence_ITEM(ev, 0); +#endif + } else { + Py_INCREF(Py_None); + value = Py_None; + } + Py_DECREF(ev); + } + else if (!__Pyx_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { + value = ev; + } + if (likely(value)) { + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = value; + return 0; + } + } else if (!__Pyx_PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + PyErr_NormalizeException(&et, &ev, &tb); + if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + Py_XDECREF(tb); + Py_DECREF(et); +#if PY_VERSION_HEX >= 0x030300A0 + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + Py_DECREF(ev); +#else + { + PyObject* args = __Pyx_PyObject_GetAttrStr(ev, __pyx_n_s_args); + Py_DECREF(ev); + if (likely(args)) { + value = PySequence_GetItem(args, 0); + Py_DECREF(args); + } + if (unlikely(!value)) { + __Pyx_ErrRestore(NULL, NULL, NULL); + Py_INCREF(Py_None); + value = Py_None; + } + } +#endif + *pvalue = value; + return 0; +} +static CYTHON_INLINE +void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) { + PyObject *t, *v, *tb; + t = exc_state->exc_type; + v = exc_state->exc_value; + tb = exc_state->exc_traceback; + exc_state->exc_type = NULL; + exc_state->exc_value = NULL; + exc_state->exc_traceback = NULL; + Py_XDECREF(t); + Py_XDECREF(v); + Py_XDECREF(tb); +} +#define __Pyx_Coroutine_AlreadyRunningError(gen) (__Pyx__Coroutine_AlreadyRunningError(gen), (PyObject*)NULL) +static void __Pyx__Coroutine_AlreadyRunningError(CYTHON_UNUSED __pyx_CoroutineObject *gen) { + const char *msg; + if ((0)) { + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_Coroutine_Check((PyObject*)gen)) { + msg = "coroutine already executing"; + #endif + #ifdef __Pyx_AsyncGen_USED + } else if (__Pyx_AsyncGen_CheckExact((PyObject*)gen)) { + msg = "async generator already executing"; + #endif + } else { + msg = "generator already executing"; + } + PyErr_SetString(PyExc_ValueError, msg); +} +#define __Pyx_Coroutine_NotStartedError(gen) (__Pyx__Coroutine_NotStartedError(gen), (PyObject*)NULL) +static void __Pyx__Coroutine_NotStartedError(CYTHON_UNUSED PyObject *gen) { + const char *msg; + if ((0)) { + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_Coroutine_Check(gen)) { + msg = "can't send non-None value to a just-started coroutine"; + #endif + #ifdef __Pyx_AsyncGen_USED + } else if (__Pyx_AsyncGen_CheckExact(gen)) { + msg = "can't send non-None value to a just-started async generator"; + #endif + } else { + msg = "can't send non-None value to a just-started generator"; + } + PyErr_SetString(PyExc_TypeError, msg); +} +#define __Pyx_Coroutine_AlreadyTerminatedError(gen, value, closing) (__Pyx__Coroutine_AlreadyTerminatedError(gen, value, closing), (PyObject*)NULL) +static void __Pyx__Coroutine_AlreadyTerminatedError(CYTHON_UNUSED PyObject *gen, PyObject *value, CYTHON_UNUSED int closing) { + #ifdef __Pyx_Coroutine_USED + if (!closing && __Pyx_Coroutine_Check(gen)) { + PyErr_SetString(PyExc_RuntimeError, "cannot reuse already awaited coroutine"); + } else + #endif + if (value) { + #ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(gen)) + PyErr_SetNone(__Pyx_PyExc_StopAsyncIteration); + else + #endif + PyErr_SetNone(PyExc_StopIteration); + } +} +static +PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, int closing) { + __Pyx_PyThreadState_declare + PyThreadState *tstate; + __Pyx_ExcInfoStruct *exc_state; + PyObject *retval; + assert(!self->is_running); + if (unlikely(self->resume_label == 0)) { + if (unlikely(value && value != Py_None)) { + return __Pyx_Coroutine_NotStartedError((PyObject*)self); + } + } + if (unlikely(self->resume_label == -1)) { + return __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing); + } +#if CYTHON_FAST_THREAD_STATE + __Pyx_PyThreadState_assign + tstate = __pyx_tstate; +#else + tstate = __Pyx_PyThreadState_Current; +#endif + exc_state = &self->gi_exc_state; + if (exc_state->exc_type) { + #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON + #else + if (exc_state->exc_traceback) { + PyTracebackObject *tb = (PyTracebackObject *) exc_state->exc_traceback; + PyFrameObject *f = tb->tb_frame; + Py_XINCREF(tstate->frame); + assert(f->f_back == NULL); + f->f_back = tstate->frame; + } + #endif + } +#if CYTHON_USE_EXC_INFO_STACK + exc_state->previous_item = tstate->exc_info; + tstate->exc_info = exc_state; +#else + if (exc_state->exc_type) { + __Pyx_ExceptionSwap(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); + } else { + __Pyx_Coroutine_ExceptionClear(exc_state); + __Pyx_ExceptionSave(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); + } +#endif + self->is_running = 1; + retval = self->body((PyObject *) self, tstate, value); + self->is_running = 0; +#if CYTHON_USE_EXC_INFO_STACK + exc_state = &self->gi_exc_state; + tstate->exc_info = exc_state->previous_item; + exc_state->previous_item = NULL; + __Pyx_Coroutine_ResetFrameBackpointer(exc_state); +#endif + return retval; +} +static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state) { + PyObject *exc_tb = exc_state->exc_traceback; + if (likely(exc_tb)) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON +#else + PyTracebackObject *tb = (PyTracebackObject *) exc_tb; + PyFrameObject *f = tb->tb_frame; + Py_CLEAR(f->f_back); +#endif + } +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_MethodReturn(CYTHON_UNUSED PyObject* gen, PyObject *retval) { + if (unlikely(!retval)) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (!__Pyx_PyErr_Occurred()) { + PyObject *exc = PyExc_StopIteration; + #ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(gen)) + exc = __Pyx_PyExc_StopAsyncIteration; + #endif + __Pyx_PyErr_SetNone(exc); + } + } + return retval; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) { + PyObject *ret; + PyObject *val = NULL; + __Pyx_Coroutine_Undelegate(gen); + __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, &val); + ret = __Pyx_Coroutine_SendEx(gen, val, 0); + Py_XDECREF(val); + return ret; +} +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { + PyObject *retval; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(gen->is_running)) + return __Pyx_Coroutine_AlreadyRunningError(gen); + if (yf) { + PyObject *ret; + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_Check(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_PyAsyncGenASend_CheckExact(yf)) { + ret = __Pyx_async_gen_asend_send(yf, value); + } else + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) + if (PyGen_CheckExact(yf)) { + ret = _PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); + } else + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03050000 && defined(PyCoro_CheckExact) && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) + if (PyCoro_CheckExact(yf)) { + ret = _PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); + } else + #endif + { + if (value == Py_None) + ret = Py_TYPE(yf)->tp_iternext(yf); + else + ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value); + } + gen->is_running = 0; + if (likely(ret)) { + return ret; + } + retval = __Pyx_Coroutine_FinishDelegation(gen); + } else { + retval = __Pyx_Coroutine_SendEx(gen, value, 0); + } + return __Pyx_Coroutine_MethodReturn(self, retval); +} +static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { + PyObject *retval = NULL; + int err = 0; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + retval = __Pyx_Coroutine_Close(yf); + if (!retval) + return -1; + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_Check(yf)) { + retval = __Pyx_Coroutine_Close(yf); + if (!retval) + return -1; + } else + if (__Pyx_CoroutineAwait_CheckExact(yf)) { + retval = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf, NULL); + if (!retval) + return -1; + } else + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_PyAsyncGenASend_CheckExact(yf)) { + retval = __Pyx_async_gen_asend_close(yf, NULL); + } else + if (__pyx_PyAsyncGenAThrow_CheckExact(yf)) { + retval = __Pyx_async_gen_athrow_close(yf, NULL); + } else + #endif + { + PyObject *meth; + gen->is_running = 1; + meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close); + if (unlikely(!meth)) { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_WriteUnraisable(yf); + } + PyErr_Clear(); + } else { + retval = PyObject_CallFunction(meth, NULL); + Py_DECREF(meth); + if (!retval) + err = -1; + } + gen->is_running = 0; + } + Py_XDECREF(retval); + return err; +} +static PyObject *__Pyx_Generator_Next(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(gen->is_running)) + return __Pyx_Coroutine_AlreadyRunningError(gen); + if (yf) { + PyObject *ret; + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Generator_Next(yf); + } else + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) + if (PyGen_CheckExact(yf)) { + ret = _PyGen_Send((PyGenObject*)yf, NULL); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_Check(yf)) { + ret = __Pyx_Coroutine_Send(yf, Py_None); + } else + #endif + ret = Py_TYPE(yf)->tp_iternext(yf); + gen->is_running = 0; + if (likely(ret)) { + return ret; + } + return __Pyx_Coroutine_FinishDelegation(gen); + } + return __Pyx_Coroutine_SendEx(gen, Py_None, 0); +} +static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __Pyx_Coroutine_Close(self); +} +static PyObject *__Pyx_Coroutine_Close(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *retval, *raised_exception; + PyObject *yf = gen->yieldfrom; + int err = 0; + if (unlikely(gen->is_running)) + return __Pyx_Coroutine_AlreadyRunningError(gen); + if (yf) { + Py_INCREF(yf); + err = __Pyx_Coroutine_CloseIter(gen, yf); + __Pyx_Coroutine_Undelegate(gen); + Py_DECREF(yf); + } + if (err == 0) + PyErr_SetNone(PyExc_GeneratorExit); + retval = __Pyx_Coroutine_SendEx(gen, NULL, 1); + if (unlikely(retval)) { + const char *msg; + Py_DECREF(retval); + if ((0)) { + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_Coroutine_Check(self)) { + msg = "coroutine ignored GeneratorExit"; + #endif + #ifdef __Pyx_AsyncGen_USED + } else if (__Pyx_AsyncGen_CheckExact(self)) { +#if PY_VERSION_HEX < 0x03060000 + msg = "async generator ignored GeneratorExit - might require Python 3.6+ finalisation (PEP 525)"; +#else + msg = "async generator ignored GeneratorExit"; +#endif + #endif + } else { + msg = "generator ignored GeneratorExit"; + } + PyErr_SetString(PyExc_RuntimeError, msg); + return NULL; + } + raised_exception = PyErr_Occurred(); + if (likely(!raised_exception || __Pyx_PyErr_GivenExceptionMatches2(raised_exception, PyExc_GeneratorExit, PyExc_StopIteration))) { + if (raised_exception) PyErr_Clear(); + Py_INCREF(Py_None); + return Py_None; + } + return NULL; +} +static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject *val, PyObject *tb, + PyObject *args, int close_on_genexit) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(gen->is_running)) + return __Pyx_Coroutine_AlreadyRunningError(gen); + if (yf) { + PyObject *ret; + Py_INCREF(yf); + if (__Pyx_PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) && close_on_genexit) { + int err = __Pyx_Coroutine_CloseIter(gen, yf); + Py_DECREF(yf); + __Pyx_Coroutine_Undelegate(gen); + if (err < 0) + return __Pyx_Coroutine_MethodReturn(self, __Pyx_Coroutine_SendEx(gen, NULL, 0)); + goto throw_here; + } + gen->is_running = 1; + if (0 + #ifdef __Pyx_Generator_USED + || __Pyx_Generator_CheckExact(yf) + #endif + #ifdef __Pyx_Coroutine_USED + || __Pyx_Coroutine_Check(yf) + #endif + ) { + ret = __Pyx__Coroutine_Throw(yf, typ, val, tb, args, close_on_genexit); + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { + ret = __Pyx__Coroutine_Throw(((__pyx_CoroutineAwaitObject*)yf)->coroutine, typ, val, tb, args, close_on_genexit); + #endif + } else { + PyObject *meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_throw); + if (unlikely(!meth)) { + Py_DECREF(yf); + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + gen->is_running = 0; + return NULL; + } + PyErr_Clear(); + __Pyx_Coroutine_Undelegate(gen); + gen->is_running = 0; + goto throw_here; + } + if (likely(args)) { + ret = PyObject_CallObject(meth, args); + } else { + ret = PyObject_CallFunctionObjArgs(meth, typ, val, tb, NULL); + } + Py_DECREF(meth); + } + gen->is_running = 0; + Py_DECREF(yf); + if (!ret) { + ret = __Pyx_Coroutine_FinishDelegation(gen); + } + return __Pyx_Coroutine_MethodReturn(self, ret); + } +throw_here: + __Pyx_Raise(typ, val, tb, NULL); + return __Pyx_Coroutine_MethodReturn(self, __Pyx_Coroutine_SendEx(gen, NULL, 0)); +} +static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) { + PyObject *typ; + PyObject *val = NULL; + PyObject *tb = NULL; + if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb)) + return NULL; + return __Pyx__Coroutine_Throw(self, typ, val, tb, args, 1); +} +static CYTHON_INLINE int __Pyx_Coroutine_traverse_excstate(__Pyx_ExcInfoStruct *exc_state, visitproc visit, void *arg) { + Py_VISIT(exc_state->exc_type); + Py_VISIT(exc_state->exc_value); + Py_VISIT(exc_state->exc_traceback); + return 0; +} +static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) { + Py_VISIT(gen->closure); + Py_VISIT(gen->classobj); + Py_VISIT(gen->yieldfrom); + return __Pyx_Coroutine_traverse_excstate(&gen->gi_exc_state, visit, arg); +} +static int __Pyx_Coroutine_clear(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_CLEAR(gen->closure); + Py_CLEAR(gen->classobj); + Py_CLEAR(gen->yieldfrom); + __Pyx_Coroutine_ExceptionClear(&gen->gi_exc_state); +#ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + Py_CLEAR(((__pyx_PyAsyncGenObject*)gen)->ag_finalizer); + } +#endif + Py_CLEAR(gen->gi_code); + Py_CLEAR(gen->gi_name); + Py_CLEAR(gen->gi_qualname); + Py_CLEAR(gen->gi_modulename); + return 0; +} +static void __Pyx_Coroutine_dealloc(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject_GC_UnTrack(gen); + if (gen->gi_weakreflist != NULL) + PyObject_ClearWeakRefs(self); + if (gen->resume_label >= 0) { + PyObject_GC_Track(self); +#if PY_VERSION_HEX >= 0x030400a1 && CYTHON_USE_TP_FINALIZE + if (PyObject_CallFinalizerFromDealloc(self)) +#else + Py_TYPE(gen)->tp_del(self); + if (self->ob_refcnt > 0) +#endif + { + return; + } + PyObject_GC_UnTrack(self); + } +#ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + /* We have to handle this case for asynchronous generators + right here, because this code has to be between UNTRACK + and GC_Del. */ + Py_CLEAR(((__pyx_PyAsyncGenObject*)self)->ag_finalizer); + } +#endif + __Pyx_Coroutine_clear(self); + PyObject_GC_Del(gen); +} +static void __Pyx_Coroutine_del(PyObject *self) { + PyObject *error_type, *error_value, *error_traceback; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + __Pyx_PyThreadState_declare + if (gen->resume_label < 0) { + return; + } +#if !CYTHON_USE_TP_FINALIZE + assert(self->ob_refcnt == 0); + self->ob_refcnt = 1; +#endif + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); +#ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + __pyx_PyAsyncGenObject *agen = (__pyx_PyAsyncGenObject*)self; + PyObject *finalizer = agen->ag_finalizer; + if (finalizer && !agen->ag_closed) { + PyObject *res = __Pyx_PyObject_CallOneArg(finalizer, self); + if (unlikely(!res)) { + PyErr_WriteUnraisable(self); + } else { + Py_DECREF(res); + } + __Pyx_ErrRestore(error_type, error_value, error_traceback); + return; + } + } +#endif + if (unlikely(gen->resume_label == 0 && !error_value)) { +#ifdef __Pyx_Coroutine_USED +#ifdef __Pyx_Generator_USED + if (!__Pyx_Generator_CheckExact(self)) +#endif + { + PyObject_GC_UnTrack(self); +#if PY_MAJOR_VERSION >= 3 || defined(PyErr_WarnFormat) + if (unlikely(PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "coroutine '%.50S' was never awaited", gen->gi_qualname) < 0)) + PyErr_WriteUnraisable(self); +#else + {PyObject *msg; + char *cmsg; + #if CYTHON_COMPILING_IN_PYPY + msg = NULL; + cmsg = (char*) "coroutine was never awaited"; + #else + char *cname; + PyObject *qualname; + qualname = gen->gi_qualname; + cname = PyString_AS_STRING(qualname); + msg = PyString_FromFormat("coroutine '%.50s' was never awaited", cname); + if (unlikely(!msg)) { + PyErr_Clear(); + cmsg = (char*) "coroutine was never awaited"; + } else { + cmsg = PyString_AS_STRING(msg); + } + #endif + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, cmsg, 1) < 0)) + PyErr_WriteUnraisable(self); + Py_XDECREF(msg);} +#endif + PyObject_GC_Track(self); + } +#endif + } else { + PyObject *res = __Pyx_Coroutine_Close(self); + if (unlikely(!res)) { + if (PyErr_Occurred()) + PyErr_WriteUnraisable(self); + } else { + Py_DECREF(res); + } + } + __Pyx_ErrRestore(error_type, error_value, error_traceback); +#if !CYTHON_USE_TP_FINALIZE + assert(self->ob_refcnt > 0); + if (--self->ob_refcnt == 0) { + return; + } + { + Py_ssize_t refcnt = self->ob_refcnt; + _Py_NewReference(self); + self->ob_refcnt = refcnt; + } +#if CYTHON_COMPILING_IN_CPYTHON + assert(PyType_IS_GC(self->ob_type) && + _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); + _Py_DEC_REFTOTAL; +#endif +#ifdef COUNT_ALLOCS + --Py_TYPE(self)->tp_frees; + --Py_TYPE(self)->tp_allocs; +#endif +#endif +} +static PyObject * +__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context) +{ + PyObject *name = self->gi_name; + if (unlikely(!name)) name = Py_None; + Py_INCREF(name); + return name; +} +static int +__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UNUSED void *context) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = self->gi_name; + Py_INCREF(value); + self->gi_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context) +{ + PyObject *name = self->gi_qualname; + if (unlikely(!name)) name = Py_None; + Py_INCREF(name); + return name; +} +static int +__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UNUSED void *context) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) +#endif + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = self->gi_qualname; + Py_INCREF(value); + self->gi_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name) { + __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); + if (unlikely(!gen)) + return NULL; + return __Pyx__Coroutine_NewInit(gen, body, code, closure, name, qualname, module_name); +} +static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( + __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name) { + gen->body = body; + gen->closure = closure; + Py_XINCREF(closure); + gen->is_running = 0; + gen->resume_label = 0; + gen->classobj = NULL; + gen->yieldfrom = NULL; + gen->gi_exc_state.exc_type = NULL; + gen->gi_exc_state.exc_value = NULL; + gen->gi_exc_state.exc_traceback = NULL; +#if CYTHON_USE_EXC_INFO_STACK + gen->gi_exc_state.previous_item = NULL; +#endif + gen->gi_weakreflist = NULL; + Py_XINCREF(qualname); + gen->gi_qualname = qualname; + Py_XINCREF(name); + gen->gi_name = name; + Py_XINCREF(module_name); + gen->gi_modulename = module_name; + Py_XINCREF(code); + gen->gi_code = code; + PyObject_GC_Track(gen); + return gen; +} + +/* PatchModuleWithCoroutine */ +static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) { +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + int result; + PyObject *globals, *result_obj; + globals = PyDict_New(); if (unlikely(!globals)) goto ignore; + result = PyDict_SetItemString(globals, "_cython_coroutine_type", + #ifdef __Pyx_Coroutine_USED + (PyObject*)__pyx_CoroutineType); + #else + Py_None); + #endif + if (unlikely(result < 0)) goto ignore; + result = PyDict_SetItemString(globals, "_cython_generator_type", + #ifdef __Pyx_Generator_USED + (PyObject*)__pyx_GeneratorType); + #else + Py_None); + #endif + if (unlikely(result < 0)) goto ignore; + if (unlikely(PyDict_SetItemString(globals, "_module", module) < 0)) goto ignore; + if (unlikely(PyDict_SetItemString(globals, "__builtins__", __pyx_b) < 0)) goto ignore; + result_obj = PyRun_String(py_code, Py_file_input, globals, globals); + if (unlikely(!result_obj)) goto ignore; + Py_DECREF(result_obj); + Py_DECREF(globals); + return module; +ignore: + Py_XDECREF(globals); + PyErr_WriteUnraisable(module); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch module with custom type", 1) < 0)) { + Py_DECREF(module); + module = NULL; + } +#else + py_code++; +#endif + return module; +} + +/* PatchGeneratorABC */ +#ifndef CYTHON_REGISTER_ABCS +#define CYTHON_REGISTER_ABCS 1 +#endif +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) +static PyObject* __Pyx_patch_abc_module(PyObject *module); +static PyObject* __Pyx_patch_abc_module(PyObject *module) { + module = __Pyx_Coroutine_patch_module( + module, "" +"if _cython_generator_type is not None:\n" +" try: Generator = _module.Generator\n" +" except AttributeError: pass\n" +" else: Generator.register(_cython_generator_type)\n" +"if _cython_coroutine_type is not None:\n" +" try: Coroutine = _module.Coroutine\n" +" except AttributeError: pass\n" +" else: Coroutine.register(_cython_coroutine_type)\n" + ); + return module; +} +#endif +static int __Pyx_patch_abc(void) { +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + static int abc_patched = 0; + if (CYTHON_REGISTER_ABCS && !abc_patched) { + PyObject *module; + module = PyImport_ImportModule((PY_MAJOR_VERSION >= 3) ? "collections.abc" : "collections"); + if (!module) { + PyErr_WriteUnraisable(NULL); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, + ((PY_MAJOR_VERSION >= 3) ? + "Cython module failed to register with collections.abc module" : + "Cython module failed to register with collections module"), 1) < 0)) { + return -1; + } + } else { + module = __Pyx_patch_abc_module(module); + abc_patched = 1; + if (unlikely(!module)) + return -1; + Py_DECREF(module); + } + module = PyImport_ImportModule("backports_abc"); + if (module) { + module = __Pyx_patch_abc_module(module); + Py_XDECREF(module); + } + if (!module) { + PyErr_Clear(); + } + } +#else + if ((0)) __Pyx_Coroutine_patch_module(NULL, NULL); +#endif + return 0; +} + +/* Generator */ +static PyMethodDef __pyx_Generator_methods[] = { + {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, + (char*) PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, + {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, + (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS, + (char*) PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, + {0, 0, 0, 0} +}; +static PyMemberDef __pyx_Generator_memberlist[] = { + {(char *) "gi_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL}, + {(char*) "gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + (char*) PyDoc_STR("object being iterated by 'yield from', or None")}, + {(char*) "gi_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL}, + {0, 0, 0, 0, 0} +}; +static PyGetSetDef __pyx_Generator_getsets[] = { + {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + (char*) PyDoc_STR("name of the generator"), 0}, + {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + (char*) PyDoc_STR("qualified name of the generator"), 0}, + {0, 0, 0, 0, 0} +}; +static PyTypeObject __pyx_GeneratorType_type = { + PyVarObject_HEAD_INIT(0, 0) + "generator", + sizeof(__pyx_CoroutineObject), + 0, + (destructor) __Pyx_Coroutine_dealloc, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, + 0, + (traverseproc) __Pyx_Coroutine_traverse, + 0, + 0, + offsetof(__pyx_CoroutineObject, gi_weakreflist), + 0, + (iternextfunc) __Pyx_Generator_Next, + __pyx_Generator_methods, + __pyx_Generator_memberlist, + __pyx_Generator_getsets, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if CYTHON_USE_TP_FINALIZE + 0, +#else + __Pyx_Coroutine_del, +#endif + 0, +#if CYTHON_USE_TP_FINALIZE + __Pyx_Coroutine_del, +#elif PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +}; +static int __pyx_Generator_init(void) { + __pyx_GeneratorType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter; + __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type); + if (unlikely(!__pyx_GeneratorType)) { + return -1; + } + return 0; +} + +/* CStringEquals */ +static CYTHON_INLINE int __Pyx_StrEq(const char *s1, const char *s2) { + while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } + return *s1 == *s2; +} + +/* CheckBinaryVersion */ +static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + 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; +} + +/* 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 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 */ diff --git a/data analysis/analysis/dep/analysis.cp37-win_amd64.pyd b/data analysis/analysis/dep/analysis.cp37-win_amd64.pyd new file mode 100644 index 0000000000000000000000000000000000000000..6a447e637971be6de738ef46e24560162578cd30 GIT binary patch literal 366592 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%0Afh z3%?_q?05(AsYLI87uYQO1|5X?f%zj_{UA8?7{i!4954VfYC8i3 zlKRaIxC8MfyK1^%VUAHgs1y|j8s0ivZu_-Mwbfn8aD$8C2w*5C2L4uyU|0v9aNeWBa1GhDF+8p? zGzf+fE{3h0HD5PkSc7(#oVuQ3UO<``s`3-1{Go37M^XMTmj4sWKWVz<$ExzBQvMTs zDjw&fd@q)t#dggfK|`!K{P)7=P9>>jV8WqNQ&>KP!dkVzxL8gEmQ#tPFR_@~nFLAr zC%p%$Sm3t+lZ zdtr8YO_l!;h7A7Q@+YEvrSOmP<-M=NqUY!+)c)ZCR;%A&N$o?V_TA~)Ux3qu43-PF zGhJ+-!BVS*!bb+1%P?$jX0SFvFzLijjSdOFY06PNo zJV}E~=+`;#_H=S3F;Jl`6tt`GsU%Sgv}1|Z0NUh#|KLjEXF7zq_BJ%#s@?9E?~n51 zS-ynjpTyo3TXO4F`G=(ZMQ-_hn1w%^<&*fS_~c;t61b7Z?Yy}qqvL5_}tozr36ifdU@t#eBp|Bh+SU$pMXYoogV7Y`?W-2UK?<2T= z`%i+UUa;Jo#*(kFY=_CWYIg$*_W$AP1Yns%EPWJ~)PDs_ul<5$xL}!-#_}>)R*6qHyo_Fz3 z5D-u8@xFL~cX4ir)&7=I$DdRkL-0b&plUB=$DgP)wVN~QSfc8v#EW}=^wyE!T^!4h zO>K8Z<)5j_$K%D_8K_K!sunN$vpScLBUI&ecySdC$$fDl?=ZiC7pu8G%6;)7@9=Y& zcv0=3(kggG;m1Ss@!~JECeCJJxG5Sj`5?Y*DU^rTcV!^FK@cuev6S`}?a{5Qg?Di~ ziLAYr0r!G}<76IiK9(Vfdqfb+?w5CZ@1KFi^#4s`6KU!wO{8b5whm^h%&D$W^R>{N zemWhR&|Rh!2n+QmzsGjl3j8pY9U`F{^hc#qe~nby#jW�?qdhD-Gu$AC3F9A4vN8 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 fy(4}P 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 literal 0 HcmV?d00001