From 0c47283dd5434d9e7058c6c5c229bc2b547ace4e Mon Sep 17 00:00:00 2001 From: ltcptgeneral <35508619+ltcptgeneral@users.noreply.github.com> Date: Fri, 5 Apr 2019 21:01:17 -0500 Subject: [PATCH] analysis in c working --- .../__pycache__/tbarequest.cpython-37.pyc | Bin 3028 -> 3028 bytes .../__pycache__/visualization.cpython-37.pyc | Bin 3908 -> 3908 bytes data analysis/analysis.cp37-win_amd64.pyd | Bin 0 -> 366592 bytes data analysis/analysis_source/analysis.c | 35536 ++++++++++++++++ .../analysis.cp37-win_amd64.pyd | Bin 0 -> 366592 bytes .../{ => analysis_source}/analysis.py | 0 .../Release/analysis.cp37-win_amd64.exp | Bin 0 -> 795 bytes .../Release/analysis.cp37-win_amd64.lib | Bin .../temp.win-amd64-3.7/Release/analysis.obj | Bin 2145802 -> 2145866 bytes data analysis/analysis_source/compile.bat | 2 + data analysis/{ => analysis_source}/setup.py | 0 .../Release/analysis.cp37-win_amd64.exp | Bin 779 -> 0 bytes .../Release/c_analysis.cp37-win_amd64.exp | Bin 789 -> 0 bytes .../Release/c_analysis.cp37-win_amd64.lib | Bin 2052 -> 0 bytes .../temp.win-amd64-3.7/Release/c_analysis.obj | Bin 2134095 -> 0 bytes 15 files changed, 35538 insertions(+) create mode 100644 data analysis/analysis.cp37-win_amd64.pyd create mode 100644 data analysis/analysis_source/analysis.c create mode 100644 data analysis/analysis_source/analysis.cp37-win_amd64.pyd rename data analysis/{ => analysis_source}/analysis.py (100%) create mode 100644 data analysis/analysis_source/build/temp.win-amd64-3.7/Release/analysis.cp37-win_amd64.exp rename data analysis/{ => analysis_source}/build/temp.win-amd64-3.7/Release/analysis.cp37-win_amd64.lib (100%) rename data analysis/{ => analysis_source}/build/temp.win-amd64-3.7/Release/analysis.obj (99%) create mode 100644 data analysis/analysis_source/compile.bat rename data analysis/{ => analysis_source}/setup.py (100%) delete mode 100644 data analysis/build/temp.win-amd64-3.7/Release/analysis.cp37-win_amd64.exp delete mode 100644 data analysis/build/temp.win-amd64-3.7/Release/c_analysis.cp37-win_amd64.exp delete mode 100644 data analysis/build/temp.win-amd64-3.7/Release/c_analysis.cp37-win_amd64.lib delete mode 100644 data analysis/build/temp.win-amd64-3.7/Release/c_analysis.obj diff --git a/data analysis/__pycache__/tbarequest.cpython-37.pyc b/data analysis/__pycache__/tbarequest.cpython-37.pyc index 397a8ae8d43189daf11e62043679860a8c264822..65f353b325753a94ea84b7c0c7405b9af2cabfc0 100644 GIT binary patch delta 27 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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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 +#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_source/analysis.cp37-win_amd64.pyd b/data analysis/analysis_source/analysis.cp37-win_amd64.pyd new file mode 100644 index 0000000000000000000000000000000000000000..97e10770d83db2c4e7c7497cb80012c88242f27f GIT binary patch literal 366592 zcmd?Sd3+RA)<4`?3If=4Pzr;Bv=~MZK`<_4BASK-s-Yt&C=nE*fTE%zbdMm5V3N_c zY{hM69LL9Hbkxyt8OH^5#)K$gQ9)1valyS~y8tSS%GCS)o?BI2-D&(i@ABWvhjiC+ z&$(y2=bn4+(lwKp`wDzMUm^Z1%jbI$-~3l8pTGW5oagg(?X$A0?_ZtXIQqrB$Qwsb zoOS8E;GDTvT{8E=D}vK6yzh-*@oM?)d2WPMMv)zQHc}U5kA; zK}yGgY5bdU7(R;Sa;ZGwHL!M&N9k|hPE83{Ue}?h0&>3E->WB2CkuUbfGKV(^vxj7 zjhb&Czn|88Ygo7QZ-?fKbn^M?Ru}quInQ!@FU5PGB3-?`ztC6g5Syd?;ONZxQ9Lh; z1CAtV=b7x!_z0l_?nT9vODMa6rS+El3G*}h${pm4cfJ|<}*SGD;H4UDl z3JQr$P8PD*U^?EA;J-9cnZ;7hk-$*|K)W@^`lw&1;L>9x3qoP~NEjx_{%Q zXnFltdC~s-=u!VuUbORzG%ut6)&4EXTVPo!EjbNef#;j#S=ijj@3sI6)igE*?rN6X zUH~%U=a&{4@n~tW5nogq44sP#f`+*}V(uzioBS`3G&IFZ%9;%G{L&$Y87&=Vn2Smc zzz0K9Tas5pn>TH}v8uGP@`b$m;pZ*EeW3AQsHas6r~RRPi9*=d1VM---95@V-_1VX-FWR(Yaz)B5C5 zMKH$(E6_N_vaDns?hJFQQ9sNVEj7$F$>|-X;*yBDdL?Z%Y`$rj1rgK#XCMq&Z&_L= zn77ET?MPr)f%3lO0H9e;)wr@LnMA2n-n7fqwqB$8%Clo#szaS>vWypji6YcQ*D^q*LOhL5OL?$s?s6UOsc!3--?Ik);ONPFdC>iNXy&;Q6-lj zu&nf}yS=acutxQ&-pY#&1JaWKRBQ5l*#ZE8zehsC19 zu({8C&oFnP(ZsamJrF{~Y&AC4A(c}O{+E)PgrZKR*NgDvQ@jtzIqYn z>oYEIV#AtD$kxI<)|`HB`fo}Jm4!j)VV+_7uW%j$aP4hqaR^E*@HMPOKX{>y(%080ObX1=`zR0r^WOKKRj~y9a{Bik4W^sGnJa zT53uxy{iyaU1G$mi!J?r^qFRpF_hPzsp~{dP~E@I`|2RTijC$SL8A=UW!1$-S+lVM zEaM-rAA_5+bX7*6su|)xizL8O3}f#`-2Rrg(EJ50AhADUcVfzJl4U|>rqkK zGrtbG_FMpkSp6pB1^7$&JK?^q4(;1WXntI`xZl8+{1T)X^+korFVsao>go@h=DPrZ zAn2oK8fIa?Aym0(6s0tyVokJrS<_A<@QnX$IJelhC#pW+>Acil%9OC1;nr!9$qsNo zsh-J~a1VF6M?Ee)u_@It`5kVa&XWoWgU(<$?5qKuhr;LJ`UvIFMG)xF`A>Y<4{iOz+Gn%xiIyrS8#edTnW2rgC67mGc$OaZKj+1|iQ_QLHw?4Y z(%(arL$j(iBcd0fYstf9_CO3UQ&@f8crTRsc7yeTi)?P}Opyb{+1MtKkNdAD{+X0^O4ghj7yg@_LQJ{pu#5 zg=epDt<~2syDgz!p$dCSkV*6^y?m#hGV4$0} zp6(@Qfo}d+@XjqrKeRj0&A$rYtF@c)nJ4P2oYJxal=zYd@IjkG7u)<|&19eN;&QDY z%r>^bn6B000-d-nUxySgD`$WooAzQCxTA~9LnX0^k%6lMFNC@qiL*+Kf{nQBU?dJ% z8c7_o&WLv}4OhGsEiuO&5~*mO+u0mZRL~r$XqpSpx~hNbqq0o~dOMn3_xfu~eT#Y3 z8Ajd#-}z$mC9ceaH*HIP1XY!7f_%F)Y>#y`ZqT2nZxq!i9WNdJIG*@!+7>Nr*c9uE z=%NtK7+(hfDO^*FXrJ%gigsGx?>Uxkkr?3|Bk@FO<cq6MJA@VTv;-6Tn^gWF?lFrRg zkzpzb7)l)?hVeRD1HLD+30V45z=^I0gi(-u1%0bw{-u-^UBtSmhHYWI&*g5!Rju}@xs#TE~`*)p}7m1Dl+%QCzc)(8*kM6 z^H7)7Z|50SV0cr9JYTf`@VXB9zUa}z=kV(Y?dko$AgT*qQ);Zp15qT)2>i8qUiT_f z>pM^Lh3ePjRmHW#ahd9fXI*j8_)VjuUq}zyPk6F zUeC`S@>wFE7s=;I@_CAU4wKK{%I9hFIZ8ead_JAm0^F+KMO1cI14tL?6M?t3rtE?SnsFxWoL7;M!(M93Ne6kk<9_hSZ?T^T!_y!OM%?+`1O?p%edUXX1F4?|rxcG(D@Z1r0O(TeH> zjU9W}55K4rj3Cgk6yk<~{K%f2N0u07m*~)?3y<(ci!6OU7)pWu2}Kce zWU*nbqbj;o(;+>K>QcI;SA(FGUzoMlS^7~_r#W_?5r-5;?la6Hqj7DtkELI+jI!Bh zMGu3+>2K68+~A9x-uXINF~NwI#s zJQ0_t#ExKVxLN8j%3e>t^c}mPS4jjq1C(F6h9ZMU?jK=o=)C5SLe46o9gQy)0pK}2 z^iV2Eg{p|P9q~5qARlT1X50-=_TB(*WeXo6 z8!{US|AhZywDR8wS=F}SJmDL)meS(A` zp8#y-l*l1VdGCJ%kE`I#(OAz$Im7H^>CJeC@pHTeqPLq`C9Gozk^=fUq~6>IG=YX! zMX%cA>+mR{*YD$-HI~kMyuR@+_4+XKkkF%h`Few;SIF!6*G4eBP3XgEJbYZL9#4;$ z+JZ)bxQJ@yt4`{b5ivIyv^(I1J+*?hy;YiTWgf`1^w*aF5t>I|qrQJ0oBwz;|21s> z^(W-TY7KKV?l)NDhomC%1SOm&G7A2M@TULYXwV?*lpkCZqC}p;)5fL+htj(c_egOq zV*`PNa@qXeC^2fb2L18{JMHfxgOmha_ua7hFqUfuX4!sK2T}PHHt$2Z{+$A z;Z6Tc+D$_LaCe4WC*f&sxk8%J-Xg!=9&tC(m%FwY7nR|Gv(iHk8F@8JUd_J>GXD4V zBICb7fbyzFy_y(7FO{}kSiZkvge&7>6rzj=x3^u`+l;gTFkbXXpq+WKv7AI)rvFFU zQ$oLTSBAX5l$Jz0Mw{@ofHLV%D~Vp(xmS?(b(TD9M6DU}JbR&3xljZKdGg*P&o1>M znb~5PNIR9;uha4z3SvcQCGtw-dBrk;Iv2u{R|l>YE6*X%RHZA=CKUSrN}it)m+604 zHO8ZMX2|o8(j@;M$EEX6RI*L#oAB^`rfWyN`$MawoV+Y{(MdG13mi`Tu1rJ=G(dm2i zF8WUAGcpqD{xhJJu!$kd$rm7Ljyz<<+->P$F+JKubWtQe2P2SKB}U^n(L%$j_N}g5 zgpo&lB-k1Wwnl=jkzi{i*cu78MuM%8*=&u>W@{vP-b0={81Z?t3}jq!-4TXi#211o z+6|df0iT;g@#Of^3^G50aX!Y~(US~}$M-IM6b&2yikWT?*BMrRI6fW{TpRTp^#k${ z(wU(m^dEKy44YU>(@5y+&Y*3gmw0SGGGuOVo~}x+08Mou^`;F#IjAkeT}dwMSLmr# z^nm|^(^IbK86(XI^z{5c&;w*b&)wJLphwwf{et=6ZCl`GCd_FKP!*?5FuhV4!Ifd@ z-%A5Qs5uKZH>WOQ&Y1-f#YflTuMU5+%16$RY1CU86qSTm1;#a~I@ZI|zaTK|r9>L{ zd=P?QmK`{xT}f%zm~S%6YQBTcEIDfuJATy4P`=Whz#&aJtk`Z}%6b)O8wlb}F3WqyMv{WG3)$CDu$Px3*aYU(seD8)ZMp(ReTK(j2sZA z)j}j|$kGLid^P4S!#r<%4R!SuD2W~gM;462s1y2G6}BVWF|QE5y6pyO^HKII+oQF} z(B3F*;tj(pFw8@fKfxZ+bU_WKoHiu4Gx>-3*xZ>p_#P*!){WNDPY~gcAXd1F5EvrW_!XS6OL`N0c6W3yX zpg()PIq(?>wK#ADy9k)xk-=f|D@oKP+nVt_VlG`yVod$zSsJI2qgu$?m_kl2I+yK! zC;iiu_5qgvAMzT`^)HYS%5=VQ^dg9A65YPO56=wq*BA!PzP8RNOBF(&Z?gX>vh*{d zfm8_ycY{Plxur*lvwko*O;WC-F!Fd4evydUk%z2U7ph`BM%*Y5&f8X~nZLAMI9FmH z(sXGSumqX~yFUM+WHF(SEVr#;)77*FYQSz}G>5Pl!DjXbLy|inYVu97t&O%*^;tzS z49grkHSVGR9)j5b(?5jv#~yUc98|T5EF2&UP|Hc}LSoauK$+|H!)yYFW)o=Xw+P0q z#Bez(*dSUf$JJ}1qHadTs%XThXpN5MOjG>|>H8P=bc2A(sGlQD%p?5^R-Wn!JG1l^ zKnj(^KfqjZ|Crnd8a{%IE&XRufw6uBEGStaFf+B`yv=e=qJp-CnVNC?EBMgyOBXKk zMbSI?e^2m){=%s?tD`8OCL)~DLRpVqJ(7(egcP#&cg(58Iwqe5F(9}?y9rFkI+ty- z^jeSx+g`o{CJz7#Hg+_d4)L`0mGroN$5kZUezrs!vo|(O`xENiU0b1Xe!gtGT4Z6S zjPemhv0jF`F8LRkE2jnmjrX8ljEvhjvO;hRf-yrq0+y`zxCD$Ln7~x3G)Qkt{OU>) zw2#F0gDA>`J{U<~$N?~>+(-tiP$Uw^>8M_+-4+m#9& zo$bNA3v~7rb#^{<_AVHS>42!v3y3OEwb9b=29K%J@wN$%?6;p^;k;eQw?P1G!lPJ` z(sC*gF;_vpznO`7wr=6H+K+>ZlWK-_qf-B0K@lIC(unPcxA37@nZtD2U(gr8TZ9q8 zBP&NML}W2~e1>DU^!LFD<2+>Gh9u9RIjOFC1G>AidilW{`GF6NkG4n9mLGwnxF{jQjYiD7t34&6@^zrc$ z_GHHOj8I_;gJodsxLFlrdX20xxbi|Oo$lutWTHw8b4&>Z)x&5VQ3BE- zTl9ix0BE>Y-H=SnQW(csOq-4UrxIwlj=eArLtm z&`MCSC?NKR3ih}z+bkS$zfKh0Adk<$KR86Fe$!>%{5xLtB=Z=redd(dhY}6~zK2Zk ze$0u|c!6Q7_dN_tqB}^X8zr{@>N^h+Rvx%6!XLD~i3W6>7!bYNI`q>VqvBy^x+TNw zWE#{#tVzu$7N3K4E6xg%{Ujn>%Xl_kGt4ljVdyn!mJz=IYpTvc6G#uhV0p2#YCv80 zuuvCr&J<%NDbP%%pP$UMxoV(#d(YPu7vNPNUgv{ zvVRt|>d8`@M_7_rT)(lHl!}Fm0Zz5(5%n#vobJ>T>X${uChwGB#$o*l-5nHqYP`WID1bEGTe%4k5j zEUK^VL-hHUo`n7&j3b?ZW~;hK3`r*{rYM)rvLCObQ~8rs5pykS#smfA${vHW7;g1} z#CSYTlMraA6vscJ$h?vCHLhK7#NO*|E2xZi<&wL#MACLT=nJg;_=rG#S3+<#XW3fA zycUhjTGG={plINh=S1-*kCLW6xuiNVArDJb zt7r{i(?jVZ6iibZofD~88(k7Mm({X&f4p(ek z^j&JWOfZI40swP_cmZLA&E`O#rFek)mU5cFsAxt$2}1wQsCX08NT~u8#qD8X3(2^a zqDaL@ft%|P4pcLmff|SjF$fyCGka;v2>z*mwtu3a5KvDp#%v`u)3|*}FA6Kr$0zby z4MM_J6KRfAv`}7Hc(Ofk%L78-@F4I-5|dH95=lL;d=}63$mZf~*`PH!vKd3!5T5dx zoFShRAPmp?;P&#^KzV3lNsvhIu(c{I64@NM`ASGcwF$I5@CYk|`75K7dr!+ymtZYo zuA@&br-62qvYbqHHF|2qti^0MRJwhMPO>8)d8z%Zo_f*vY$K*SaL5vYX|oQhjVunb>%wWlu&_QOkZ!4ik~tDO1dhJ%Y6lvRv5GXMhAurya>^7u@c|h3CTj-o$7&Y_3k7 z=tQn=r>{Gl3Zs z(WC75TB6oU4dhw~j)9S^dRVZoA*{R$WMpsQj_uHA5(Kvaf^)L-(z)2A%9m>&h$%6? zl!O&J*#mWmQ@4ki%=igQo!OrI8WkI(y(5rM$dybmb{HbJy6uI&w*M+$)*uvr6U8FZ zWURn2zXNAYXOS~>`XjK!_HpVRWFKwm#nWj5`UB4ECh#rh6u9wKV2eP5XnmU?ir5*5 zdJUtzws;8>XRXAM(C7CjUPRT8klLoUe+v*sk&qF_s2?lIw{fI}UfT$nGS?7Txue&- zQ7D0AmBF@d>G!2=@l4u3)-xc(el*}CSS*@2Gl-;w%*&!f8p=fxm`SNB4WAo*}H9Apb&IJ1RSF`O>WqzRK6-sC^b40a;R zO}(b#+6$s@}xgl81y|1pxWGFo_zKNSS13}i9b=g6dJJf5UOVH zu&;4XpkWpS4^94C%w=t$AtLv)Y9lD#gyIo%RvqRd5Lh>qZpD2#KB*Reb@-cQ>F=_6 zNRA?ktTqw-i>|EPD2W|nn7vP(jup{yKtV8Ca_l{3Ri5x?Z0Y*jdEAS4((Td)) zQJgbi$Y<@xGid49vOTF|EPWu*VM4nK56h6N(;t`C;lC5Bb}?@Qz9U$yLy6QdU-C{E zNxL<}$*B@^1m8_~i&1q^mAN{!cWbJk+I+Pd6`X3A!#|%wldz%#O??wD0eurf`3mh- z+%49PKN$s0RpnK!MI12nYHce(K!_Z%rFR#}C1Fm1hEaG3{Jp9$NtDo5zJyFWMxP0P z|9+(LL{Of>Gz41UM~=BSVSG}5g)cAA_@n5#8gA*0wlCybJNi6W48u(S3m5XLiEB>h zlx?bt&%nZegjRL5w^}y2@%)g+SIMhk{J@wi!fgP~G{2=6fdZ+{PDM#=92B-!N}yo@ zhyXK%dp~4M_yc6rJQ)ieVWOQ$UZWNJ?Ft{VqR0mkE&1O?%Zh7vqg<LJw*ptq<@-rthq(_;K-Z6j{Nh^5~YL7+l&RTa0+GEgY%@ z8kwtNe*=o!I7@G81AzqYbZ}x;B{XJCe+SDU3oU(3+7vI059)wI=Ad67Owe|KU(?@V zlE32JCC6h>Y&3sdXcTM+4}6zlqT8PbibL>s;hlkQ7)fI@`}rIdanY)%;# zHZQLXo1b!$A#^^s-MIb+;!LmaU-tDnM6o#zK48NS`O#Jv%)Ud!!G--AbGUQ z<$YxF0Yq>N8) zo5TkHUKP9ZJ+U#iRkyG*T6IT2RVmx$=s2#eK>1efaeP*S@mB3#T+zPmUW)U<=q3Ss~uu;d9OWct2}*B19@r(Ce9syzB`5eL49AY0YzU1jeLf>Z20 zwb0Z~2M*WR-*k1-ZLM=n zykg6BUmFD$E&MI0ttuYy-h!UkAPIH(RvC4;5nazmHE8r~d1QI&b z6HI*>FX2$j!B2%Y4|j`udK@a+NFf>$G|SAT>SMh#ryhI9c)BWaHe$tXA+x2rant;g zn(6Cm3f7LQs9IaJq=-XP48!H`+F9@Exnhhk>Rk@bN>Xd;`ZE& z(G590_cLQCPrK)i)>8djq3y}iZ#g~p%Yc@idtNO|>x%>^XV2a3T%wSwRnNV25+C&b z7^qdxy@4g#cM?(d+|S~j^xXeMal7X}0|=z&{)RpG)wqL~ya@%%z5yw_!lcOm9<0;S zj|bm1=IfYVq~kZ=OdfU$gB-}qe2r@>AU{Y`jZDP)kj8+tv$XT;@yTD>Ff}cn>$lSfTp9)Bj<>mYd|bsT!i(pxWY=$i1``_l(oj#*D0WsSga7y zNnd9Gg08)k`pDs7%bPf{eB?y3Dq6>4Oe|^HEPE&|{hwf1Ih0rrauR5KT#(7~RLNWl zyHFPTx|1mhVOJ)%(k>bE7AF{{Gd@in1L5XLjS%imTtK*!EdAVbI9;|JpEBg#9vumS z%V8hrpd|)eEP9xaDLj4d2=am04x!=2>M``zf(sKQS_~WA20E3CM z-hD-`E#goQN*=_NPiZ9diX+)dAgxc%<{&P$F4N?NetQmzYQ_%bb~Bd404Z{9iVX(h zWpWFQa}=F4_;09_g#Md1Xyh1Y;q6K(hW^_fkZ0Dc?pVJX?_j7SqvJBGY!3$5=2sC+ z$6@=};at{TjjEKD1sc|g86{EcRcQKjj^i!;ZPXS~-PaOJ|GgBKHaTbIV3x;v@gwLb zULOxcFq+da@?=EI4i{5AXp<6iog*g1UNDAm-rvJ9wML)^6ueMMDiTPo2#&?gS%UPvZ?~rO(1GOwQOB9{o5&sg#L0*+dNuuk4`hKE$j!mJGA#_ zb4@7l)cUG{%^_Tst#5AYgRu^ftql!q#yqH79_gBm<1kXGUxj@#KNVdw7sy|EQufK* z{yJ8`$Ud1WZi@+(gt1X3(xoYk!Bf|)N8F_o-ivwIHQ~ThYa;`j!?-G2%doh)?F^*- zBB(k%uo(q1>V6${BUHSXT$!7ZxUEaS4qNvpA)Dn-fDHbfX@5KS7kciqZS51T)G zb`wS6%aq{H62WgYS1GXvs#jGblySvAgLERFv5s`2l|*o#A$F1Zs!&-=bFxq4CTguZ z@Kno)#3A`jh|-?4hVnH{+0cK^mx)CIP(`qMMa2u#_4Urt8I+*Y_^{i5$Mp@ElyTOMQC#2D!$J^A=B z=DcA9&cxsEJo7b|85P^2H+wiaEPUM$v@6 zVT%PK@%czGZxl@NSwV#Z{%2fCa`sS~^v>*9k-oVSvnTAu4JMbz%h+8ObY>`+{Fj_- zvyRx38&lhA%$>qJ5(iDu$z~W!9T1u@0o;Gt{-xkM*1IYZx}NM{-BHkjTHRnFG<9mr zvi;YyP!NTdqNhA)Imwe?5jQNUhf%%+0_I3*fUGqL+$c*OAmH(MMFEfU2>2W$EnrM# zv5Sq*QSybfAtRKAfJfyNa7h|CQ^3FkG?1_0fPl{|Np=}Rr?<}$a5@=7!h~(cm(2Gd zd(UK+lgUzI=3aw@-k}@16w}{_)(Hn<^&12dGW6iwD0_~Wdg=w1-G)v)(7@ETskPw= zcK>m$p|q8-^~rEi#-ViM34JX$L$ML@g(yI0n3B++#tRm)-_`FcVBeiCj zM8s>wl(GJmK>t86oNHLAvNAAVtd^3hosqGpy&`WB8^QC#pIZN&+ z36xK3v8h7rkNqn`mAIzksB0k$duZsM(4=|_P2As{wZvLRH$qb-HIJ1h#O!EJeP{Kz zGLoS`*#~*`f0oktDmDPurMQmGgm4RRkvv7wO}FwVin#pbU;c@#L-ihwuk)g(*-mw8 zH8H4hgzU)KXozcgV~_S80P?wOxyjOB!8Kfp{sO;GvVBtDH0()PTw`xfe0~rHdJ6!O zJqOX^bGQ_+o;kqF$v>CEa~V8r_*9@1{S1HOWHtcp6h7b(pRwswY+tum`M!a{J4H$_ zg$;(vtdFQlR4y|(AqO9mRY1(Ux0p9xq7c^h=Vg`=-%MjQ%J!f-bcW?8Klu!#J_Axu z;3C-sQ6tK@@sCR6aXjNfWojK-LpOiRc$I;a2RSa}t?{$>@H38E^5WBQQMvRc7i za}w=|8sS~ByemEy{Y|L9X%yFgd~1Ac(CMpP{-ixQ`G8;z(}Re*(cs_Ohl5>~jKUg> zaf$9lHG%M3H5D7@odV`d!in+L7_-+#3>h}oU^E(^RE*PNiq1?FzP1m+QnI?73iW0J zK;+LMn8pO;(JcLGx241aWftALn=*iZ>~00&Ro z=Q#V(<y|r_^aNANg z2P;3zvDw8WS)B0SbqJ%aaU&o|C>hI0wSnk1oC#)UkNvnOVcCE716^F}!fu7Omo6mA z&e~(2%YT}oMTo{qkrm_GgwqORGcdagBiJBoz%2d7O1FUq(Kj-GR}F2lw(i;eHZo2X zNVSLpH!|9|oZQ+v#KfG_@OXaASva8xC0moDSq3iLF$Hn{=$b0q_W)v{s|efH4N#fF z#a%A`RMfRq*lVl8A||Y)E(+Cu5(r^}F3|8#;K5aXpn(hg`7AmiRR2?<>?tax3KIHj zINw5I>zmJD%-r@8N^*HpS25^Q@sQG362X?MFiww(!B0#mX_G1Zgg&Pua_YyXix=6& z$FVpbBN@CYbqQ*DufVA)cBMa-^TA?ZqqvHX|)2WYK+e+4S{E#!^K z4cO14d9k67=12QrR2l2UH7&S^_Tk<+{U(|U{Gu$XtkAz7j$Q!!C^yAEGc3da>i85F zBlU-Qw%JaW8eUgc&4lZ)HnS@pKxV zO8JbZVTlGM+B3|BbC_m4u53^Fy!lIxamKTOOgw&TwNc+%R55Szo0+LZsTcCm)T%_ zGr>k?fVl{$Zj~G9DY(7M>#~*`D{b>lF#C-toNwTNJ)83!o%0Ps%FH*S zcD{kD$$TT4=Nrf?^UZjNHbhgIZ$$ru!C)oxjhF!6%*uM>T0(at{+%2JFG!B+o!PZh$0Xm>Q>7;?lq$rcLLJm$7OUmI=W96d)TBA3Gm0&>SPKCZqE_1rLcPXu9}>|~I8;QWOoKA~6V+x^sMD431} z5N=?`5M6hi)r8~Ar8ZbirV-=_7+m_5FBAHQ8s*CcLcH- z1=9j?s(1XCxlGy~C-0g-h|Ax==z@K3I75-iY zKo)<6G4gkq;_rz(TjAfM;IHtv&ALr&UJXz(mMU_6WxU>D%M77?rIqM$W9`Nc6e8k- zS}3_U`D)x`VEO~P_Jp>0mnS@+eCE zVrX;#7}H#5nL#H2yzE2l1^WmOQ72DGC-Ey*@7O!eC{f0M!^!$n!#v)@(_l$5p0ras z7=f>n^C&ujwoGAAUaq}!&4Z^ItMfW46_u6jVscUm&G#fZ34H`O6B+D3$t#1j=p6Y1 zC*@oDe~@oZdf;PueuxB32csuW{U-Fz&*6(Yx%AiQapgPAmM^C0#e-VRp?kgrecNshUpU6* zn$CJ^Q}ujTV?G1p61C?EyT}sy7r!9afn8*ygGTwtAT~ZE^gHkfM$jF`6){Hx4J3Ys z(2%vn4r|tPZ34|4mz(~-o=AK^ayyVfWH`xpAJH)Y*dmYS{|js8FjT{!8}vSlijjuA zU(#bArT&~2rDJbMj$oYP&nK3OX0`961{nzKo5A#BnR_DR(Hz2b2*LeuHH*1s?=}pb ztU&b|%obVw<_+b9XEP?3_ZM9g2IChkmkH0ChRi|e%tIJMrqPSgSc!=VPMqqvjq^-a zzh?lM{Z3x|2`|__VG8JKCZB@#V+ApLSP2ot^xdIAab@xDK&>|9T$Ho=Es)~cN_=5T z7ZCjcLD)dGrcr9vj*FM?xC%d`fWOD>Z|A<%bMF;V&iLpYXKDoJSwze>q+npKv*vJ8 zutA0`^^1#qfrg#vGPv3RXCPrUa@ah*?L|B(+ireeetzj3ZgIuYi4)NJWGuZE78_{T zA~4$GAuy!QSWOkh1+t~((bDW_|7;#_jY6ib0MsT31cPnIT(~~1w%-5+sh~1#Xwl3gHzM|11Rf+ ze*4d!y#O_!fukE)SLjZ`*wX|-S@W7>u@@8p{oD3=5m1PIa@7BS&py|}IyMi^vd>is zWuLFk{T2HpWVaJ?*e74?1Io00t}LT{)^R@kK0u@m^nC5s2`Gqty;5Gk4FzeIRzH>t z^zkhP1^gRpe>?Y=cG9^PFXfoJd8(nOeDq=t;`DzRUnLwsVMbDDNqN#UA zWthefG;nVs)`j7ggL1AQ!!e&l(3tNh^5ef0f_67?+)0`_H;M7Ev*8Hy_8QmoD0NDP z8ceSO!svKhEa1gxJ465SAeMuzHAUBOY{0n%)4xO{fn>u6RH|B6hLc)KK#MO1A1Q0l z;QmvGkQ4nQmLfOXqxE9x1EQrtP%*FAOO}um=)XG9A8+B}vrgty5_I|xx_6c|7!7v0cTb>fX3&xHAgUNnQrdIhCogs zs{?+6Sf0#FmxavfIK(&maR{e&;Sgp^n@ObuHf zqT}gDc%aQbo-Z52L<8F?i*Q_0Bb0#bLoJ>5h{xwz`UX6; zZGHBSLh&2WZt8@PnhleEQ^}Q>x1)F~(?mdo{s|}v(`bM|+{SUuKq5g=<=Pa*o?rzm zb09BARoVP9V=D~N+0&B=KY<1n?BmFGc*x|Izmc)6!q|D1K8!{L4$cH)QK?cfc0Zou zaX*}Uj;Dw&*og1=K^Xf1th#h=IF8SNnRKdE-Dn&R*GMtGnS2#9Zc@Zk09;d#Kzhp) z9&F158|RUl+P5-$V>YtITAZ+qv9#-O1sOu$71}+3j$MYEVysicwiqw~0V;q8>C%j#i%X22 zw+mEpsnKI?*Pt+}EM}EQs?|oJz?Eyh4}7r}%Z{3_y&=}vHUVWqFM@k|=;sGy8#rX} zOn(SBq5U0MVTj_>rzlIdh6U{ki@r0~@7hVS1?c^gM#b>e@ z%nOu4{*nu`wl65a?*m{HdEslF$cM9&=S^b&+%q5B>qfNJ~TSELoLSsiENbn+4%3y9ic^h3!<_^Ij8f)fG5_?!D0zxN?S)%kTAKZmqpFJ0$AIe&PWs=Ve z!SRkOE3*(W4?r^(31sL$ot9GSe}qyvNL8>8Whx$HqW&>nhda4|kT_pHHX(x3QshvB zP_P>7C^=2KH59n7DN=r35Z_q+xhi@DhoCU(G4bwOaUdR#R>2;2pzjYUKlmGJV8Jk_ z2knnT@i3vK|NU^BafGD-P{A4s%`=hLemAK*gmvS$AlE?17F?i+$evnrTk;>cfuUg2 zI971Vtf|4C?vx^&2G*Cd#JG05b4H&CfIG0zVAm&4>_p?sG5IPAIM{(fX?hS#Cci~J z4i0p}?x4V#=*!d{B`^KC1VQZSg4_=4j*cScg+*9AhCvdx8F8x&^2gY`&>&mh;Fl|* zB%HPkemir?)V?;J^NxJPF*NIaZTYyXDgRe#5x!&H!shGf=Sr!Iz>R0(QJ9-Q@$7o& z#}0KPu&)SC;Eq)2=M(oyxEP7o(Sgv{pZhWFUY8v63gfUCPQCjl>*LrA2h^-A!L={i zIdv6u!sA1L6WczoAaW2`W0*r2(^Vsfjf!i`YFIW#*B^i&JG_MvL3Y`(+xF<`spFl; z&NhkqMWy3?v5BmDDkcHpq27T8F&!q+OlGjnE&`b+Z3?AQKDsD&tWkbd33JHPa5R5` zGYE46!*INhTDLeP96uv9fFZMnXQ@7LDzo|mMM4jK!p^*^6cRw94I%E+c&;LtS~~1H zh5!gdG3&&=h!?rnS&pZHf9XxNM|(p?uZ=i#J)-#c%j z$3-fBj3RpmtA*kG0-3X+BX(71O@z&FVGn`E8uY{*YI&BBYS44)Nbq5gsrCUjRm5!< zQ-kDL21YR%Ss_pWt2a<0Ia~ou>CA{Z4)*p@D7{cO(6|jtVIjylzzad%{k0uHK$dr* zg0}DZ8g_%{C^d$qDCePg$Mgo&$K$*>%5Z|m^lTIC1)~~zS8QDeTxeD}jehQf5f;t>`h4B9@Y_1E{;lOGnQ*ho@yVI6(4w9gTV#*O9rraQt%TM{K}esJ84I9Fn?2j5kzQlNecqTZCrF41%G=gsn#W(pemg$1knL zzB7E)g%e|UpimL)kpe5fyf)Cdm9~MFH=Zt~zk#z=gUHEP`ZP$AZjI?7_dSkivu{wY zzcNow!1G3M;3&@^f<~O7!rn_B^NGBRV+C6e!@PsTif|mi7>E+rLhq9?ciWjof;j06 z_oO900*e}Q_9vLhmnIIH|v|RX zE?ypnq#?``!WAu1>~S9hBJ#uL*{~PbR42aTG$+-DZxn?K#j*{A3S6I9_BOev!sbdt)U~bL#VqcI2SQ^2ai@ON%bTO3@1K6c`>xCSu6j zkS@p13k79)As0CJuS$%{Pj)F9u^~bN!BlTA6qEQ}IS~x99xcMTk_g52N>||) zYiL>!f;TIA6bBxcZBIcoIBpI?8D^t4*JCM8H%LYnY`S2XcPf}yaq%TbIMTv`F61BZ zgCJ^}z@bYd$hc61xITFA}O(^svFHTE3x>;wnr=Fsuu~upq&;lwi07cll9R%33V% z#(x`%@ju!S3Lx3wKesou1Iae=h_`hN=-VnNiVFYDcmwZd>h;)vnLOn=$<1Nq=ZNAx zmBoeXOgIH_oH%8Dp)QNY9W;etCxcL@e%MoyS6-Z)`UyB8x;aIT{?Egbf}hZyt;(Qj z;Enb(G=?1GK6_UxVnzQ`fPwxM!?0}|M|8_+9{iYx?M7oUO*Qs3yo^-dKuDkDWT_;^jDHatPW8Mi~epwsTe6SSS(3sq z275QLbZ27ecXpSfBf7~b*vuW?L1+CPe#h;1h^-Jwow?75 zAAU~6x6lP=~bLzaL76nkK36DoG3HD={0)ZhLYt!rCGd( z)HkdIP72P{e|C2+sJat^#gA%N^#=;@ z3!skUJ-8#X^=be9Lk)iF0jKmj`_{188EqWH54Z#V>O*l&0t=nvBhgYYWN9c}3SQx+ zB8ih$Vf3;F=jnkRFxT)TG?8&WQrPTD?|>+M4%hx7^gI$%KA23d!Ksz#+AxTyUxkc7 z6a8wECW+h?7xWE$*J%E!ARI5;(pCi~b&9s5O2au{AabOD)4}ml)knfa1)pNc;tmFX%39Q9V2Xext*4a119k5&4<^I~0n~ zHW7l;H!A___0;Mb@uLxuAIV5)!$31O(L~Ti;s=2++{es-e=P9S1ZuWnsxR{N^^MRyUF1K-DU|eB^yxa%2@jFNfarRFYr+s^J-tNPl5_ zWh^-Ie})c0BEFn^m`?9XZp6DBfx;UgLsYXI)kw?)Gk#l2z?HK{$T5cHfXA~r%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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 PS{duD)Zr1@!~gLY6bh`4 literal 0 HcmV?d00001 diff --git a/data analysis/build/temp.win-amd64-3.7/Release/analysis.cp37-win_amd64.lib b/data analysis/analysis_source/build/temp.win-amd64-3.7/Release/analysis.cp37-win_amd64.lib similarity index 100% rename from data analysis/build/temp.win-amd64-3.7/Release/analysis.cp37-win_amd64.lib rename to data analysis/analysis_source/build/temp.win-amd64-3.7/Release/analysis.cp37-win_amd64.lib diff --git a/data analysis/build/temp.win-amd64-3.7/Release/analysis.obj b/data analysis/analysis_source/build/temp.win-amd64-3.7/Release/analysis.obj similarity index 99% rename from data analysis/build/temp.win-amd64-3.7/Release/analysis.obj rename to data analysis/analysis_source/build/temp.win-amd64-3.7/Release/analysis.obj index ed4272a0c367fb7cfbb41de498ce114fe0bf988c..a750cf1d82c29a2ac5cfbf67bdbae82bcc5fdf0d 100644 GIT binary patch delta 329 zcmeDB)5LfRh_x6P{{LrWNNG!DUlC*RZ!^!*o2z}-%)YiwNiF!0);1QVpueBraEKr#DnULz7t=nGckou7GhLlb^Xl1aB#9E<4yMX;{4L0 z+mZ@*&C2*gZ4%nZaVK+FonY(UHo z#2i4(3B+7L%nigmK+Frod_c?(!~#Gp2*g4_EDXdVKr9NxVn8eo#1cR(3B*!BEDgjm zKr9Qya@()i%Wpfz7&N_`O~DT4p6v(N6dJZM{+RB#S3#L^yfHCXopqrc6GPL)nd*$n6A!90%1(T#&U7hcvJj&ZtLbM3hKZ9c8E;NjVoI7k zg~^4nfAdWy729TBhjv~EMj&PaVrC#_0b*7lW&>h&Am#vKP9Ww2Vs0Sj0b*Vt<^y7W zAQk{(K_C_aVqqW_0b)@g76W2&AeI1PNg$R2Vrd|j0b*GomfOzjAiwq)qto==YzlVU gIoTD;w=v$B-ndsmnQ`ItrF#|n#Xycm1uQ@=0HH2bMgRZ+ diff --git a/data analysis/analysis_source/compile.bat b/data analysis/analysis_source/compile.bat new file mode 100644 index 00000000..6cd1838f --- /dev/null +++ b/data analysis/analysis_source/compile.bat @@ -0,0 +1,2 @@ +python setup.py build_ext --inplace +pause \ No newline at end of file diff --git a/data analysis/setup.py b/data analysis/analysis_source/setup.py similarity index 100% rename from data analysis/setup.py rename to data analysis/analysis_source/setup.py diff --git a/data analysis/build/temp.win-amd64-3.7/Release/analysis.cp37-win_amd64.exp b/data analysis/build/temp.win-amd64-3.7/Release/analysis.cp37-win_amd64.exp deleted file mode 100644 index 658a70d71203fc601550acfbf954656b78aa6ab0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 779 zcmZ8fQI69v5S_Nb0z#;jR($c1kA8FowbHao3j(Pk0KHD0bc&o-c-wdXv3v!z=@0trPYP;dS^%8 z+vC|A_zurI5U)8zPw66MGNY%3`XpkbsVM?K2>RL-%!pM*?La(N7{o@{Gnl<9Sn9o! ziO^neGYOCAzcS}imn`w-rsPu5z#oihq|&s+$E)ahMBgiwXnHb7I2e&ZNP@8+4CxZv zc&)VgFbU}<9MME(pNTC94`9-&t_?hm8I@V=2}NFxuu6tNaTFU`OYeZI&IOW7h8q+)n?B>CSwV0nDx#1oetoZ>0%` IX!rleU+*=go&W#< diff --git a/data analysis/build/temp.win-amd64-3.7/Release/c_analysis.cp37-win_amd64.exp b/data analysis/build/temp.win-amd64-3.7/Release/c_analysis.cp37-win_amd64.exp deleted file mode 100644 index 950404a9b9ce4eb2a97c358b67cd22fb0c352cc7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 789 zcmZWn&2G~`5S}DJ0U?xJDh@sPkV7iS%5fqms;CqZfrv^&)S!yPO3}u2{ve%I0iMH#h~Uhyt%GWT%#nX@p(m(^ z_z^A^*|Is?!Z5A?RFU^-2=#Z?w>3)KhLl`l|LS1QVix9FY7!*fetRY3Ig7a8BT3F- znvY{?=DQ$xf$5KsYjA|}abY2{a&>4gXd(}M15|KFfkC-55HHV*LlTl-c)FQE=MvI6HaNR?Js#%Wy~ zJD8{MB)ENt%naQ|R)N?z1I#N-T;Q(`bIig>b3N<~Sq1ow?j!(S4>vib@ z+xV!o`8x3F+V9a&#@~r82(Mt!u*-Y6gkhj?UXtHPsMuxKV0a~%A+B4;NpFz-)3UGB zVE>5l1`*LeCM?2A9(tRYbeUYE19p8SvWc>5ERogc6tC31N178CsRPq{1dZZMthQ8z JLzEByfgc5Pfk%3l>5FdMz?iB;e3E%~y+rkPAg3s+&e>dfpfts3r2DCV+C{QuV~C ze}-GtI~V=|M~)o$0b$18O&yxJwS==5C{f`W!X|zx{ zmw8ng#sf0$(tawB;}(o_x?1FLi(Rb7LVkq%S-O1u2y%ft$l}z$x9ht{y+QBY(0JT@ zV%W9%j{H6~+$N8Y#+^zhu(I?^wM4PlePOx1PM`3c`l-}-99@GZlL)yhS}Y)dbf_W$ z0pZRvr_4Dt36q@4MTFxMZpr4=fhZ&mpD42Ua@Uh8u2|iSC{7C$_nnR&LYl2OkI_b2 zL~$h*X2pF|jvQHW3sTZ`)UZm&n)}2i<*`&OMtBS>_cv`2$74+8Rupwy`CPftX2DXG xTUK$-`=uN?a^3>?z7E$W9Vy9+obcV8h?rhvkcI*8gx}6Wz(i)ozfb&Q@)uJ9qay$S diff --git a/data analysis/build/temp.win-amd64-3.7/Release/c_analysis.obj b/data analysis/build/temp.win-amd64-3.7/Release/c_analysis.obj deleted file mode 100644 index 8a8326549d80fb64ce84d23055d61f51d9caf3b7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2134095 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%0Ar(pu^m*_a~j5jWMd;>EF>F~xjhXwej|+S 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