From 0894b6e266c6b5d17de2f7590a3d110a2f94d39c Mon Sep 17 00:00:00 2001 From: Alastair Date: Sat, 11 May 2024 20:51:22 +1000 Subject: [PATCH] pre-commit fix --- .../library/cy_library/total_least_squares.c | 9882 +++++++++-------- .../cy_library/total_least_squares.html | 8 +- 2 files changed, 5078 insertions(+), 4812 deletions(-) diff --git a/src/perception/lidar_pipeline/lidar_pipeline/library/cy_library/total_least_squares.c b/src/perception/lidar_pipeline/lidar_pipeline/library/cy_library/total_least_squares.c index b745bf8ee..44cfb6cf0 100644 --- a/src/perception/lidar_pipeline/lidar_pipeline/library/cy_library/total_least_squares.c +++ b/src/perception/lidar_pipeline/lidar_pipeline/library/cy_library/total_least_squares.c @@ -17,20 +17,20 @@ END: Cython Metadata */ #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ #if defined(CYTHON_LIMITED_API) && 0 - #ifndef Py_LIMITED_API - #if CYTHON_LIMITED_API+0 > 0x03030000 - #define Py_LIMITED_API CYTHON_LIMITED_API - #else - #define Py_LIMITED_API 0x03030000 - #endif - #endif +#ifndef Py_LIMITED_API +#if CYTHON_LIMITED_API + 0 > 0x03030000 +#define Py_LIMITED_API CYTHON_LIMITED_API +#else +#define Py_LIMITED_API 0x03030000 +#endif +#endif #endif #include "Python.h" #ifndef Py_PYTHON_H - #error Python headers needed to compile C extensions, please install development version of Python. +#error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.7+ or Python 3.3+. +#error Cython requires Python 2.7+ or Python 3.3+. #else #if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API #define __PYX_EXTRA_ABI_MODULE_NAME "limited" @@ -44,913 +44,905 @@ END: Cython Metadata */ #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof - #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#define offsetof(type, member) ((size_t) & ((type *)0)->member) #endif #if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) - #ifndef __stdcall - #define __stdcall - #endif - #ifndef __cdecl - #define __cdecl - #endif - #ifndef __fastcall - #define __fastcall - #endif +#ifndef __stdcall +#define __stdcall +#endif +#ifndef __cdecl +#define __cdecl +#endif +#ifndef __fastcall +#define __fastcall +#endif #endif #ifndef DL_IMPORT - #define DL_IMPORT(t) t +#define DL_IMPORT(t) t #endif #ifndef DL_EXPORT - #define DL_EXPORT(t) t +#define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #define HAVE_LONG_LONG +#define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG - #define PY_LONG_LONG LONG_LONG +#define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL - #define Py_HUGE_VAL HUGE_VAL +#define Py_HUGE_VAL HUGE_VAL #endif #define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX #if defined(GRAALVM_PYTHON) - /* For very preliminary testing purposes. Most variables are set the same as PyPy. - The existence of this section does not imply that anything works or is even tested */ - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 1 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #undef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 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_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) - #endif - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif - #undef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 +/* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ +#define CYTHON_COMPILING_IN_PYPY 0 +#define CYTHON_COMPILING_IN_CPYTHON 0 +#define CYTHON_COMPILING_IN_LIMITED_API 0 +#define CYTHON_COMPILING_IN_GRAAL 1 +#define CYTHON_COMPILING_IN_NOGIL 0 +#undef CYTHON_USE_TYPE_SLOTS +#define CYTHON_USE_TYPE_SLOTS 0 +#undef CYTHON_USE_TYPE_SPECS +#define CYTHON_USE_TYPE_SPECS 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_GIL +#define CYTHON_FAST_GIL 0 +#undef CYTHON_METH_FASTCALL +#define CYTHON_METH_FASTCALL 0 +#undef CYTHON_FAST_PYCALL +#define CYTHON_FAST_PYCALL 0 +#ifndef CYTHON_PEP487_INIT_SUBCLASS +#define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) +#endif +#undef CYTHON_PEP489_MULTI_PHASE_INIT +#define CYTHON_PEP489_MULTI_PHASE_INIT 1 +#undef CYTHON_USE_MODULE_STATE +#define CYTHON_USE_MODULE_STATE 0 +#undef CYTHON_USE_TP_FINALIZE +#define CYTHON_USE_TP_FINALIZE 0 +#undef CYTHON_USE_DICT_VERSIONS +#define CYTHON_USE_DICT_VERSIONS 0 +#undef CYTHON_USE_EXC_INFO_STACK +#define CYTHON_USE_EXC_INFO_STACK 0 +#ifndef CYTHON_UPDATE_DESCRIPTOR_DOC +#define CYTHON_UPDATE_DESCRIPTOR_DOC 0 +#endif +#undef CYTHON_USE_FREELISTS +#define CYTHON_USE_FREELISTS 0 #elif defined(PYPY_VERSION) - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #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_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) - #endif - #if PY_VERSION_HEX < 0x03090000 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif - #undef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 +#define CYTHON_COMPILING_IN_PYPY 1 +#define CYTHON_COMPILING_IN_CPYTHON 0 +#define CYTHON_COMPILING_IN_LIMITED_API 0 +#define CYTHON_COMPILING_IN_GRAAL 0 +#define CYTHON_COMPILING_IN_NOGIL 0 +#undef CYTHON_USE_TYPE_SLOTS +#define CYTHON_USE_TYPE_SLOTS 0 +#ifndef CYTHON_USE_TYPE_SPECS +#define CYTHON_USE_TYPE_SPECS 0 +#endif +#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_GIL +#define CYTHON_FAST_GIL 0 +#undef CYTHON_METH_FASTCALL +#define CYTHON_METH_FASTCALL 0 +#undef CYTHON_FAST_PYCALL +#define CYTHON_FAST_PYCALL 0 +#ifndef CYTHON_PEP487_INIT_SUBCLASS +#define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) +#endif +#if PY_VERSION_HEX < 0x03090000 +#undef CYTHON_PEP489_MULTI_PHASE_INIT +#define CYTHON_PEP489_MULTI_PHASE_INIT 0 +#elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) +#define CYTHON_PEP489_MULTI_PHASE_INIT 1 +#endif +#undef CYTHON_USE_MODULE_STATE +#define CYTHON_USE_MODULE_STATE 0 +#undef CYTHON_USE_TP_FINALIZE +#define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) +#undef CYTHON_USE_DICT_VERSIONS +#define CYTHON_USE_DICT_VERSIONS 0 +#undef CYTHON_USE_EXC_INFO_STACK +#define CYTHON_USE_EXC_INFO_STACK 0 +#ifndef CYTHON_UPDATE_DESCRIPTOR_DOC +#define CYTHON_UPDATE_DESCRIPTOR_DOC 0 +#endif +#undef CYTHON_USE_FREELISTS +#define CYTHON_USE_FREELISTS 0 #elif defined(CYTHON_LIMITED_API) - #ifdef Py_LIMITED_API - #undef __PYX_LIMITED_VERSION_HEX - #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API - #endif - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 1 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_CLINE_IN_TRACEBACK - #define CYTHON_CLINE_IN_TRACEBACK 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #undef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 1 - #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 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #endif - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #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_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 1 - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #endif - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif - #undef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 +#ifdef Py_LIMITED_API +#undef __PYX_LIMITED_VERSION_HEX +#define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API +#endif +#define CYTHON_COMPILING_IN_PYPY 0 +#define CYTHON_COMPILING_IN_CPYTHON 0 +#define CYTHON_COMPILING_IN_LIMITED_API 1 +#define CYTHON_COMPILING_IN_GRAAL 0 +#define CYTHON_COMPILING_IN_NOGIL 0 +#undef CYTHON_CLINE_IN_TRACEBACK +#define CYTHON_CLINE_IN_TRACEBACK 0 +#undef CYTHON_USE_TYPE_SLOTS +#define CYTHON_USE_TYPE_SLOTS 0 +#undef CYTHON_USE_TYPE_SPECS +#define CYTHON_USE_TYPE_SPECS 1 +#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 +#undef CYTHON_USE_UNICODE_INTERNALS +#define CYTHON_USE_UNICODE_INTERNALS 0 +#ifndef CYTHON_USE_UNICODE_WRITER +#define CYTHON_USE_UNICODE_WRITER 0 +#endif +#undef CYTHON_USE_PYLONG_INTERNALS +#define CYTHON_USE_PYLONG_INTERNALS 0 +#ifndef CYTHON_AVOID_BORROWED_REFS +#define CYTHON_AVOID_BORROWED_REFS 0 +#endif +#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_GIL +#define CYTHON_FAST_GIL 0 +#undef CYTHON_METH_FASTCALL +#define CYTHON_METH_FASTCALL 0 +#undef CYTHON_FAST_PYCALL +#define CYTHON_FAST_PYCALL 0 +#ifndef CYTHON_PEP487_INIT_SUBCLASS +#define CYTHON_PEP487_INIT_SUBCLASS 1 +#endif +#undef CYTHON_PEP489_MULTI_PHASE_INIT +#define CYTHON_PEP489_MULTI_PHASE_INIT 0 +#undef CYTHON_USE_MODULE_STATE +#define CYTHON_USE_MODULE_STATE 1 +#ifndef CYTHON_USE_TP_FINALIZE +#define CYTHON_USE_TP_FINALIZE 0 +#endif +#undef CYTHON_USE_DICT_VERSIONS +#define CYTHON_USE_DICT_VERSIONS 0 +#undef CYTHON_USE_EXC_INFO_STACK +#define CYTHON_USE_EXC_INFO_STACK 0 +#ifndef CYTHON_UPDATE_DESCRIPTOR_DOC +#define CYTHON_UPDATE_DESCRIPTOR_DOC 0 +#endif +#undef CYTHON_USE_FREELISTS +#define CYTHON_USE_FREELISTS 0 #elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 1 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #ifndef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #ifndef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #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_GIL - #define CYTHON_FAST_GIL 0 - #ifndef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 1 - #endif - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #ifndef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 - #endif - #ifndef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 - #endif -#else - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 1 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #ifndef 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 - #ifndef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 1 - #endif - #ifndef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 1 - #endif - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #elif !defined(CYTHON_USE_UNICODE_WRITER) - #define CYTHON_USE_UNICODE_WRITER 1 - #endif - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #ifndef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 1 - #endif - #ifndef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) - #endif - #ifndef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) - #endif - #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 1 - #endif - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #ifndef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #endif - #if PY_VERSION_HEX < 0x030400a1 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #elif !defined(CYTHON_USE_TP_FINALIZE) - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #if PY_VERSION_HEX < 0x030600B1 - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #elif !defined(CYTHON_USE_DICT_VERSIONS) - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) - #endif - #if PY_VERSION_HEX < 0x030700A3 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK 1 - #endif - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 - #endif - #ifndef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 1 - #endif +#define CYTHON_COMPILING_IN_PYPY 0 +#define CYTHON_COMPILING_IN_CPYTHON 0 +#define CYTHON_COMPILING_IN_LIMITED_API 0 +#define CYTHON_COMPILING_IN_GRAAL 0 +#define CYTHON_COMPILING_IN_NOGIL 1 +#ifndef CYTHON_USE_TYPE_SLOTS +#define CYTHON_USE_TYPE_SLOTS 1 +#endif +#ifndef CYTHON_USE_TYPE_SPECS +#define CYTHON_USE_TYPE_SPECS 0 +#endif +#undef CYTHON_USE_PYTYPE_LOOKUP +#define CYTHON_USE_PYTYPE_LOOKUP 0 +#ifndef CYTHON_USE_ASYNC_SLOTS +#define CYTHON_USE_ASYNC_SLOTS 1 +#endif +#ifndef CYTHON_USE_PYLONG_INTERNALS +#define CYTHON_USE_PYLONG_INTERNALS 0 +#endif +#undef CYTHON_USE_PYLIST_INTERNALS +#define CYTHON_USE_PYLIST_INTERNALS 0 +#ifndef CYTHON_USE_UNICODE_INTERNALS +#define CYTHON_USE_UNICODE_INTERNALS 1 +#endif +#undef CYTHON_USE_UNICODE_WRITER +#define CYTHON_USE_UNICODE_WRITER 0 +#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_GIL +#define CYTHON_FAST_GIL 0 +#ifndef CYTHON_METH_FASTCALL +#define CYTHON_METH_FASTCALL 1 +#endif +#undef CYTHON_FAST_PYCALL +#define CYTHON_FAST_PYCALL 0 +#ifndef CYTHON_PEP487_INIT_SUBCLASS +#define CYTHON_PEP487_INIT_SUBCLASS 1 +#endif +#ifndef CYTHON_PEP489_MULTI_PHASE_INIT +#define CYTHON_PEP489_MULTI_PHASE_INIT 1 +#endif +#ifndef CYTHON_USE_MODULE_STATE +#define CYTHON_USE_MODULE_STATE 0 +#endif +#ifndef CYTHON_USE_TP_FINALIZE +#define CYTHON_USE_TP_FINALIZE 1 +#endif +#undef CYTHON_USE_DICT_VERSIONS +#define CYTHON_USE_DICT_VERSIONS 0 +#undef CYTHON_USE_EXC_INFO_STACK +#define CYTHON_USE_EXC_INFO_STACK 0 +#ifndef CYTHON_UPDATE_DESCRIPTOR_DOC +#define CYTHON_UPDATE_DESCRIPTOR_DOC 1 +#endif +#ifndef CYTHON_USE_FREELISTS +#define CYTHON_USE_FREELISTS 0 +#endif +#else +#define CYTHON_COMPILING_IN_PYPY 0 +#define CYTHON_COMPILING_IN_CPYTHON 1 +#define CYTHON_COMPILING_IN_LIMITED_API 0 +#define CYTHON_COMPILING_IN_GRAAL 0 +#define CYTHON_COMPILING_IN_NOGIL 0 +#ifndef CYTHON_USE_TYPE_SLOTS +#define CYTHON_USE_TYPE_SLOTS 1 +#endif +#ifndef CYTHON_USE_TYPE_SPECS +#define CYTHON_USE_TYPE_SPECS 0 +#endif +#ifndef 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 +#ifndef CYTHON_USE_PYLONG_INTERNALS +#define CYTHON_USE_PYLONG_INTERNALS 1 +#endif +#ifndef CYTHON_USE_PYLIST_INTERNALS +#define CYTHON_USE_PYLIST_INTERNALS 1 +#endif +#ifndef CYTHON_USE_UNICODE_INTERNALS +#define CYTHON_USE_UNICODE_INTERNALS 1 +#endif +#if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 +#undef CYTHON_USE_UNICODE_WRITER +#define CYTHON_USE_UNICODE_WRITER 0 +#elif !defined(CYTHON_USE_UNICODE_WRITER) +#define CYTHON_USE_UNICODE_WRITER 1 +#endif +#ifndef CYTHON_AVOID_BORROWED_REFS +#define CYTHON_AVOID_BORROWED_REFS 0 +#endif +#ifndef CYTHON_ASSUME_SAFE_MACROS +#define CYTHON_ASSUME_SAFE_MACROS 1 +#endif +#ifndef CYTHON_UNPACK_METHODS +#define CYTHON_UNPACK_METHODS 1 +#endif +#ifndef CYTHON_FAST_THREAD_STATE +#define CYTHON_FAST_THREAD_STATE 1 +#endif +#ifndef CYTHON_FAST_GIL +#define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) +#endif +#ifndef CYTHON_METH_FASTCALL +#define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) +#endif +#ifndef CYTHON_FAST_PYCALL +#define CYTHON_FAST_PYCALL 1 +#endif +#ifndef CYTHON_PEP487_INIT_SUBCLASS +#define CYTHON_PEP487_INIT_SUBCLASS 1 +#endif +#if PY_VERSION_HEX < 0x03050000 +#undef CYTHON_PEP489_MULTI_PHASE_INIT +#define CYTHON_PEP489_MULTI_PHASE_INIT 0 +#elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) +#define CYTHON_PEP489_MULTI_PHASE_INIT 1 +#endif +#ifndef CYTHON_USE_MODULE_STATE +#define CYTHON_USE_MODULE_STATE 0 +#endif +#if PY_VERSION_HEX < 0x030400a1 +#undef CYTHON_USE_TP_FINALIZE +#define CYTHON_USE_TP_FINALIZE 0 +#elif !defined(CYTHON_USE_TP_FINALIZE) +#define CYTHON_USE_TP_FINALIZE 1 +#endif +#if PY_VERSION_HEX < 0x030600B1 +#undef CYTHON_USE_DICT_VERSIONS +#define CYTHON_USE_DICT_VERSIONS 0 +#elif !defined(CYTHON_USE_DICT_VERSIONS) +#define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) +#endif +#if PY_VERSION_HEX < 0x030700A3 +#undef CYTHON_USE_EXC_INFO_STACK +#define CYTHON_USE_EXC_INFO_STACK 0 +#elif !defined(CYTHON_USE_EXC_INFO_STACK) +#define CYTHON_USE_EXC_INFO_STACK 1 +#endif +#ifndef CYTHON_UPDATE_DESCRIPTOR_DOC +#define CYTHON_UPDATE_DESCRIPTOR_DOC 1 +#endif +#ifndef CYTHON_USE_FREELISTS +#define CYTHON_USE_FREELISTS 1 +#endif #endif #if !defined(CYTHON_FAST_PYCCALL) -#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if !defined(CYTHON_VECTORCALL) -#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) #endif #define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS - #if PY_MAJOR_VERSION < 3 - #include "longintrepr.h" - #endif - #undef SHIFT - #undef BASE - #undef MASK - #ifdef SIZEOF_VOID_P - enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; - #endif +#if PY_MAJOR_VERSION < 3 +#include "longintrepr.h" +#endif +#undef SHIFT +#undef BASE +#undef MASK +#ifdef SIZEOF_VOID_P +enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void *)) }; +#endif #endif #ifndef __has_attribute - #define __has_attribute(x) 0 +#define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute - #define __has_cpp_attribute(x) 0 +#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 +#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(__cplusplus) - /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 - * but leads to warnings with -pedantic, since it is a C++17 feature */ - #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) - #if __has_cpp_attribute(maybe_unused) - #define CYTHON_UNUSED [[maybe_unused]] - #endif - #endif - #endif +#if defined(__cplusplus) +/* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ +#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) +#if __has_cpp_attribute(maybe_unused) +#define CYTHON_UNUSED [[maybe_unused]] +#endif +#endif +#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 +#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_UNUSED_VAR -# if defined(__cplusplus) - template void CYTHON_UNUSED_VAR( const T& ) { } -# else -# define CYTHON_UNUSED_VAR(x) (void)(x) -# endif +#if defined(__cplusplus) +template +void CYTHON_UNUSED_VAR(const T &) {} +#else +#define CYTHON_UNUSED_VAR(x) (void)(x) +#endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR - #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) #endif #ifndef CYTHON_NCP_UNUSED -# if CYTHON_COMPILING_IN_CPYTHON -# define CYTHON_NCP_UNUSED -# else -# define CYTHON_NCP_UNUSED CYTHON_UNUSED -# endif +#if CYTHON_COMPILING_IN_CPYTHON +#define CYTHON_NCP_UNUSED +#else +#define CYTHON_NCP_UNUSED CYTHON_UNUSED +#endif #endif #ifndef CYTHON_USE_CPP_STD_MOVE - #if defined(__cplusplus) && (\ - __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) - #define CYTHON_USE_CPP_STD_MOVE 1 - #else - #define CYTHON_USE_CPP_STD_MOVE 0 - #endif +#if defined(__cplusplus) && (__cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) +#define CYTHON_USE_CPP_STD_MOVE 1 +#else +#define CYTHON_USE_CPP_STD_MOVE 0 +#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 short uint16_t; - typedef unsigned int uint32_t; - #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int16 uint16_t; - typedef unsigned __int32 uint32_t; - #endif - #endif - #if _MSC_VER < 1300 - #ifdef _WIN64 - typedef unsigned long long __pyx_uintptr_t; - #else - typedef unsigned int __pyx_uintptr_t; - #endif - #else - #ifdef _WIN64 - typedef unsigned __int64 __pyx_uintptr_t; - #else - typedef unsigned __int32 __pyx_uintptr_t; - #endif - #endif -#else - #include - typedef uintptr_t __pyx_uintptr_t; +#ifndef _MSC_STDINT_H_ +#if _MSC_VER < 1300 +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +#else +typedef unsigned __int8 uint8_t; +typedef unsigned __int16 uint16_t; +typedef unsigned __int32 uint32_t; +#endif +#endif +#if _MSC_VER < 1300 +#ifdef _WIN64 +typedef unsigned long long __pyx_uintptr_t; +#else +typedef unsigned int __pyx_uintptr_t; +#endif +#else +#ifdef _WIN64 +typedef unsigned __int64 __pyx_uintptr_t; +#else +typedef unsigned __int32 __pyx_uintptr_t; +#endif +#endif +#else +#include +typedef uintptr_t __pyx_uintptr_t; +#endif +#ifndef CYTHON_FALLTHROUGH +#if defined(__cplusplus) +/* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ +#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) +#if __has_cpp_attribute(fallthrough) +#define CYTHON_FALLTHROUGH [[fallthrough]] +#endif +#endif +#ifndef CYTHON_FALLTHROUGH +#if __has_cpp_attribute(clang::fallthrough) +#define CYTHON_FALLTHROUGH [[clang::fallthrough]] +#elif __has_cpp_attribute(gnu::fallthrough) +#define CYTHON_FALLTHROUGH [[gnu::fallthrough]] +#endif +#endif #endif #ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) - /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 - * but leads to warnings with -pedantic, since it is a C++17 feature */ - #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #endif - #endif - #ifndef CYTHON_FALLTHROUGH - #if __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] - #endif - #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 +#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 #ifdef __cplusplus - template - struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; - #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +template +struct __PYX_IS_UNSIGNED_IMPL { + static const bool value = T(0) < T(-1); +}; +#define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) #else - #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) #endif #if CYTHON_COMPILING_IN_PYPY == 1 - #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) #else - #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) #endif -#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void (*)(void))(other_pointer)) #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 +#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 #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_DefaultClassType PyClass_Type - #define __Pyx_PyCode_New(a, p, 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_BUILTIN_MODULE_NAME "__builtin__" +#define __Pyx_DefaultClassType PyClass_Type +#define __Pyx_PyCode_New(a, p, 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) #else - #define __Pyx_BUILTIN_MODULE_NAME "builtins" - #define __Pyx_DefaultClassType PyType_Type +#define __Pyx_BUILTIN_MODULE_NAME "builtins" +#define __Pyx_DefaultClassType PyType_Type #if CYTHON_COMPILING_IN_LIMITED_API - static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, - PyObject *code, PyObject *c, PyObject* n, PyObject *v, - PyObject *fv, PyObject *cell, PyObject* fn, - PyObject *name, int fline, PyObject *lnos) { - PyObject *exception_table = NULL; - PyObject *types_module=NULL, *code_type=NULL, *result=NULL; - #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 - PyObject *version_info; - PyObject *py_minor_version = NULL; - #endif - long minor_version = 0; - PyObject *type, *value, *traceback; - PyErr_Fetch(&type, &value, &traceback); - #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 - minor_version = 11; - #else - if (!(version_info = PySys_GetObject("version_info"))) goto end; - if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; - minor_version = PyLong_AsLong(py_minor_version); - Py_DECREF(py_minor_version); - if (minor_version == -1 && PyErr_Occurred()) goto end; - #endif - if (!(types_module = PyImport_ImportModule("types"))) goto end; - if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; - if (minor_version <= 7) { - (void)p; - result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, - c, n, v, fn, name, fline, lnos, fv, cell); - } else if (minor_version <= 10) { - result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, - c, n, v, fn, name, fline, lnos, fv, cell); - } else { - if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; - result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, - c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); - } - end: - Py_XDECREF(code_type); - Py_XDECREF(exception_table); - Py_XDECREF(types_module); - if (type) { - PyErr_Restore(type, value, traceback); - } - return result; +static CYTHON_INLINE PyObject *__Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, + PyObject *n, PyObject *v, PyObject *fv, PyObject *cell, PyObject *fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *exception_table = NULL; + PyObject *types_module = NULL, *code_type = NULL, *result = NULL; +#if __PYX_LIMITED_VERSION_HEX < 0x030B0000 + PyObject *version_info; + PyObject *py_minor_version = NULL; +#endif + long minor_version = 0; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); +#if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 + minor_version = 11; +#else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; +#endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, c, n, v, fn, name, fline, lnos, + fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a, p, k, l, s, f, code, c, n, v, fn, name, fline, + lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a, p, k, l, s, f, code, c, n, v, fn, name, name, + fline, lnos, exception_table, fv, cell); + } +end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); } - #ifndef CO_OPTIMIZED - #define CO_OPTIMIZED 0x0001 - #endif - #ifndef CO_NEWLOCALS - #define CO_NEWLOCALS 0x0002 - #endif - #ifndef CO_VARARGS - #define CO_VARARGS 0x0004 - #endif - #ifndef CO_VARKEYWORDS - #define CO_VARKEYWORDS 0x0008 - #endif - #ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x0200 - #endif - #ifndef CO_GENERATOR - #define CO_GENERATOR 0x0020 - #endif - #ifndef CO_COROUTINE - #define CO_COROUTINE 0x0080 - #endif + return result; +} +#ifndef CO_OPTIMIZED +#define CO_OPTIMIZED 0x0001 +#endif +#ifndef CO_NEWLOCALS +#define CO_NEWLOCALS 0x0002 +#endif +#ifndef CO_VARARGS +#define CO_VARARGS 0x0004 +#endif +#ifndef CO_VARKEYWORDS +#define CO_VARKEYWORDS 0x0008 +#endif +#ifndef CO_ASYNC_GENERATOR +#define CO_ASYNC_GENERATOR 0x0200 +#endif +#ifndef CO_GENERATOR +#define CO_GENERATOR 0x0020 +#endif +#ifndef CO_COROUTINE +#define CO_COROUTINE 0x0080 +#endif #elif PY_VERSION_HEX >= 0x030B0000 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, - PyObject *code, PyObject *c, PyObject* n, PyObject *v, - PyObject *fv, PyObject *cell, PyObject* fn, - PyObject *name, int fline, PyObject *lnos) { +static CYTHON_INLINE PyCodeObject *__Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, + PyObject *c, PyObject *n, PyObject *v, PyObject *fv, PyObject *cell, + PyObject *fn, PyObject *name, int fline, PyObject *lnos) { PyCodeObject *result; PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); if (!empty_bytes) return NULL; result = - #if PY_VERSION_HEX >= 0x030C0000 +#if PY_VERSION_HEX >= 0x030C0000 PyUnstable_Code_NewWithPosOnlyArgs - #else +#else PyCode_NewWithPosOnlyArgs - #endif +#endif (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); Py_DECREF(empty_bytes); return result; - } +} #elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else - #define __Pyx_PyCode_New(a, p, 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_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif #endif #if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) - #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) #else - #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#define __Pyx_IS_TYPE(ob, type) (((const PyObject *)ob)->ob_type == (type)) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) - #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#define __Pyx_Py_Is(x, y) Py_Is(x, y) #else - #define __Pyx_Py_Is(x, y) ((x) == (y)) +#define __Pyx_Py_Is(x, y) ((x) == (y)) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) - #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#define __Pyx_Py_IsNone(ob) Py_IsNone(ob) #else - #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) - #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) #else - #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) - #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) #else - #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) #endif -#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) #if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) #else - #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) #endif #ifndef CO_COROUTINE - #define CO_COROUTINE 0x80 +#define CO_COROUTINE 0x80 #endif #ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x200 +#define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES - #define Py_TPFLAGS_CHECKTYPES 0 +#define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX - #define Py_TPFLAGS_HAVE_INDEX 0 +#define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER - #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE - #define Py_TPFLAGS_HAVE_FINALIZE 0 +#define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef Py_TPFLAGS_SEQUENCE - #define Py_TPFLAGS_SEQUENCE 0 +#define Py_TPFLAGS_SEQUENCE 0 #endif #ifndef Py_TPFLAGS_MAPPING - #define Py_TPFLAGS_MAPPING 0 +#define Py_TPFLAGS_MAPPING 0 #endif #ifndef METH_STACKLESS - #define METH_STACKLESS 0 +#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 - #if PY_VERSION_HEX >= 0x030d00A4 - # define __Pyx_PyCFunctionFast PyCFunctionFast - # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords - #else - # define __Pyx_PyCFunctionFast _PyCFunctionFast - # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords - #endif +#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 +#if PY_VERSION_HEX >= 0x030d00A4 +#define __Pyx_PyCFunctionFast PyCFunctionFast +#define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords +#else +#define __Pyx_PyCFunctionFast _PyCFunctionFast +#define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif #endif #if CYTHON_METH_FASTCALL - #define __Pyx_METH_FASTCALL METH_FASTCALL - #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast - #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#define __Pyx_METH_FASTCALL METH_FASTCALL +#define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast +#define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords #else - #define __Pyx_METH_FASTCALL METH_VARARGS - #define __Pyx_PyCFunction_FastCall PyCFunction - #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#define __Pyx_METH_FASTCALL METH_VARARGS +#define __Pyx_PyCFunction_FastCall PyCFunction +#define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords #endif #if CYTHON_VECTORCALL - #define __pyx_vectorcallfunc vectorcallfunc - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET - #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#define __pyx_vectorcallfunc vectorcallfunc +#define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET +#define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) #elif CYTHON_BACKPORT_VECTORCALL - typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, - size_t nargsf, PyObject *kwnames); - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) - #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) +#define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) #else - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 - #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 +#define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) #endif #if PY_MAJOR_VERSION >= 0x030900B1 -#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) #else -#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) #endif -#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) #if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject *)(func))->m_ml->ml_meth) #elif !CYTHON_COMPILING_IN_LIMITED_API -#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) #endif #if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) -static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { - return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject *)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject *__Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject *)func)->m_self; } #endif static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { #if CYTHON_COMPILING_IN_LIMITED_API - return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction)cfunc; #else - return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction)cfunc; #endif } -#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) #if __PYX_LIMITED_VERSION_HEX < 0x030900B1 - #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) - typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); +#define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) +typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else - #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) - #define __Pyx_PyCMethod PyCMethod +#define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) +#define __Pyx_PyCMethod PyCMethod #endif #ifndef METH_METHOD - #define METH_METHOD 0x200 +#define METH_METHOD 0x200 #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) +#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_LIMITED_API - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) +#define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) +#define __Pyx_PyFrame_SetLineNumber(frame, lineno) #else - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) +#define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyThreadState_Current PyThreadState_Get() +#define __Pyx_PyThreadState_Current PyThreadState_Get() #elif !CYTHON_FAST_THREAD_STATE - #define __Pyx_PyThreadState_Current PyThreadState_GET() +#define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x030d00A1 - #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() +#define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #elif PY_VERSION_HEX >= 0x03060000 - #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 - #define __Pyx_PyThreadState_Current PyThreadState_GET() +#define __Pyx_PyThreadState_Current PyThreadState_GET() #else - #define __Pyx_PyThreadState_Current _PyThreadState_Current +#define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) -{ +static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) { void *result; result = PyModule_GetState(op); - if (!result) - Py_FatalError("Couldn't find the module state"); + if (!result) Py_FatalError("Couldn't find the module state"); return result; } #endif -#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) #if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype)PyType_GetSlot((type), Py_##name)) #else - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) #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); + *key = PyThread_create_key(); + return 0; } -static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { - return *key != Py_tss_NEEDS_INIT; +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; + 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 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 PY_MAJOR_VERSION < 3 +#if CYTHON_COMPILING_IN_PYPY +#if PYPY_VERSION_NUM < 0x07030600 +#if defined(__cplusplus) && __cplusplus >= 201402L +[[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] +#elif defined(__GNUC__) || defined(__clang__) +__attribute__((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) +#elif defined(_MSC_VER) +__declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) +#endif +static CYTHON_INLINE int +PyGILState_Check(void) { + return 0; } -static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { - return PyThread_get_key_value(*key); +#else // PYPY_VERSION_NUM < 0x07030600 +#endif // PYPY_VERSION_NUM < 0x07030600 +#else +static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState *tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); } #endif -#if PY_MAJOR_VERSION < 3 - #if CYTHON_COMPILING_IN_PYPY - #if PYPY_VERSION_NUM < 0x07030600 - #if defined(__cplusplus) && __cplusplus >= 201402L - [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] - #elif defined(__GNUC__) || defined(__clang__) - __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) - #elif defined(_MSC_VER) - __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) - #endif - static CYTHON_INLINE int PyGILState_Check(void) { - return 0; - } - #else // PYPY_VERSION_NUM < 0x07030600 - #endif // PYPY_VERSION_NUM < 0x07030600 - #else - static CYTHON_INLINE int PyGILState_Check(void) { - PyThreadState * tstate = _PyThreadState_Current; - return tstate && (tstate == PyGILState_GetThisThreadState()); - } - #endif #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) -#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else -#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#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) +#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) +#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 > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) -static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && \ + CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) \ + _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *)name)->hash) +static CYTHON_INLINE PyObject *__Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); if (res == NULL) PyErr_Clear(); return res; } #elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) -#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError -#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem #else -static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +static CYTHON_INLINE PyObject *__Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { #if CYTHON_COMPILING_IN_PYPY return PyDict_GetItem(dict, name); #else PyDictEntry *ep; - PyDictObject *mp = (PyDictObject*) dict; - long hash = ((PyStringObject *) name)->ob_shash; + PyDictObject *mp = (PyDictObject *)dict; + long hash = ((PyStringObject *)name)->ob_shash; assert(hash != -1); ep = (mp->ma_lookup)(mp, name, hash); if (ep == NULL) { @@ -959,246 +951,252 @@ static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, return ep->me_value; #endif } -#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#define __Pyx_PyDict_GetItemStr PyDict_GetItem #endif #if CYTHON_USE_TYPE_SLOTS - #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) - #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) - #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) +#define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) +#define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) #else - #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) - #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) - #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) +#define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) +#define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next #endif #if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) +#define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject *)tp, k, v) #else - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) #endif #if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 -#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ - PyTypeObject *type = Py_TYPE((PyObject*)obj);\ - assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ - PyObject_GC_Del(obj);\ - Py_DECREF(type);\ -} +#define __Pyx_PyHeapTypeObject_GC_Del(obj) \ + { \ + PyTypeObject *type = Py_TYPE((PyObject *)obj); \ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE)); \ + PyObject_GC_Del(obj); \ + Py_DECREF(type); \ + } #else -#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #endif #if CYTHON_COMPILING_IN_LIMITED_API - #define CYTHON_PEP393_ENABLED 1 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) - #define __Pyx_PyUnicode_DATA(u) ((void*)u) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#define CYTHON_PEP393_ENABLED 1 +#define __Pyx_PyUnicode_READY(op) (0) +#define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) +#define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) +#define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) +#define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) +#define __Pyx_PyUnicode_DATA(u) ((void *)u) +#define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject *)(d), i)) +#define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) #elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) - #define CYTHON_PEP393_ENABLED 1 - #if PY_VERSION_HEX >= 0x030C0000 - #define __Pyx_PyUnicode_READY(op) (0) - #else - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #endif - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) ((int)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, (Py_UCS4) ch) - #if PY_VERSION_HEX >= 0x030C0000 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) - #else - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) - #else - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) - #endif - #endif -#else - #define CYTHON_PEP393_ENABLED 0 - #define PyUnicode_1BYTE_KIND 1 - #define PyUnicode_2BYTE_KIND 2 - #define PyUnicode_4BYTE_KIND 4 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((int)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] = (Py_UNICODE) ch) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#define CYTHON_PEP393_ENABLED 1 +#if PY_VERSION_HEX >= 0x030C0000 +#define __Pyx_PyUnicode_READY(op) (0) +#else +#define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ? 0 : _PyUnicode_Ready((PyObject *)(op))) +#endif +#define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) +#define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) +#define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) +#define __Pyx_PyUnicode_KIND(u) ((int)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, (Py_UCS4)ch) +#if PY_VERSION_HEX >= 0x030C0000 +#define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) +#else +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyUnicode_IS_TRUE(u) \ + (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) +#else +#define __Pyx_PyUnicode_IS_TRUE(u) \ + (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) +#endif +#endif +#else +#define CYTHON_PEP393_ENABLED 0 +#define PyUnicode_1BYTE_KIND 1 +#define PyUnicode_2BYTE_KIND 2 +#define PyUnicode_4BYTE_KIND 4 +#define __Pyx_PyUnicode_READY(op) (0) +#define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) +#define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) +#define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) +#define __Pyx_PyUnicode_KIND(u) ((int)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] = (Py_UNICODE)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) +#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)) +#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 - #if !defined(PyUnicode_DecodeUnicodeEscape) - #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) - #endif - #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) - #undef PyUnicode_Contains - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) - #endif - #if !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) - #endif - #if !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) - #endif -#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 !defined(PyUnicode_DecodeUnicodeEscape) +#define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) +#endif +#if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) +#undef PyUnicode_Contains +#define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if !defined(PyByteArray_Check) +#define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if !defined(PyObject_Format) +#define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#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) +#define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else - #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#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) +#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 PyBaseString_Type PyUnicode_Type +#define PyStringObject PyUnicodeObject +#define PyString_Type PyUnicode_Type +#define PyString_Check PyUnicode_Check +#define PyString_CheckExact PyUnicode_CheckExact #ifndef PyObject_Unicode - #define PyObject_Unicode PyObject_Str +#define PyObject_Unicode PyObject_Str #endif #endif #if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) - #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#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)) +#define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) +#define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #if CYTHON_COMPILING_IN_CPYTHON - #define __Pyx_PySequence_ListKeepNew(obj)\ +#define __Pyx_PySequence_ListKeepNew(obj) \ (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) #else - #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) #endif #ifndef PySet_CheckExact - #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) +#define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 - #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) - #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) +#define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) #else - #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) - #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) +#define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS - #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) - #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) - #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) - #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) - #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) - #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) - #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) - #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) - #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) -#else - #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) - #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) - #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) - #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) - #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) - #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) - #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) - #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) - #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) +#define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) +#define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) +#define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) +#define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) +#define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) +#define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) +#define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) +#define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) +#define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) +#else +#define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) +#define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) +#define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) +#define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) +#define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) +#define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) +#define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) +#define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) +#define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) #endif #if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 - #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) #else - static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { - PyObject *module = PyImport_AddModule(name); - Py_XINCREF(module); - return module; - } +static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; +} #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 __Pyx_Py3Int_Check(op) PyLong_Check(op) - #define __Pyx_Py3Int_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 -#else - #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) - #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) +#define PyIntObject PyLongObject +#define PyInt_Type PyLong_Type +#define PyInt_Check(op) PyLong_Check(op) +#define PyInt_CheckExact(op) PyLong_CheckExact(op) +#define __Pyx_Py3Int_Check(op) PyLong_Check(op) +#define __Pyx_Py3Int_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 +#else +#define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) +#define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 - #define PyBoolObject PyLongObject +#define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY - #ifndef PyUnicode_InternFromString - #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) - #endif +#ifndef PyUnicode_InternFromString +#define PyUnicode_InternFromString(s) PyUnicode_FromString(s) +#endif #endif #if PY_VERSION_HEX < 0x030200A4 - typedef long Py_hash_t; - #define __Pyx_PyInt_FromHash_t PyInt_FromLong - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t +typedef long Py_hash_t; +#define __Pyx_PyInt_FromHash_t PyInt_FromLong +#define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t #else - #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t +#define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t +#define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #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 +#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 +#define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct - typedef struct { - unaryfunc am_await; - unaryfunc am_aiter; - unaryfunc am_anext; - } __Pyx_PyAsyncMethodsStruct; +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; +} __Pyx_PyAsyncMethodsStruct; #endif #if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) - #if !defined(_USE_MATH_DEFINES) - #define _USE_MATH_DEFINES - #endif +#if !defined(_USE_MATH_DEFINES) +#define _USE_MATH_DEFINES +#endif #endif #include #ifdef NAN -#define __PYX_NAN() ((float) NAN) +#define __PYX_NAN() ((float)NAN) #else static CYTHON_INLINE float __PYX_NAN() { - float value; - memset(&value, 0xFF, sizeof(value)); - return value; + float value; + memset(&value, 0xFF, sizeof(value)); + return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) @@ -1208,25 +1206,32 @@ static CYTHON_INLINE float __PYX_NAN() { #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } + { \ + __pyx_filename = __pyx_f[f_index]; \ + (void)__pyx_filename; \ + __pyx_lineno = lineno; \ + (void)__pyx_lineno; \ + __pyx_clineno = __LINE__; \ + (void)__pyx_clineno; \ + } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } #ifdef CYTHON_EXTERN_C - #undef __PYX_EXTERN_C - #define __PYX_EXTERN_C CYTHON_EXTERN_C +#undef __PYX_EXTERN_C +#define __PYX_EXTERN_C CYTHON_EXTERN_C #elif defined(__PYX_EXTERN_C) - #ifdef _MSC_VER - #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") - #else - #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. - #endif +#ifdef _MSC_VER +#pragma message("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") +#else +#warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. +#endif +#else +#ifdef __cplusplus +#define __PYX_EXTERN_C extern "C" #else - #ifdef __cplusplus - #define __PYX_EXTERN_C extern "C" - #else - #define __PYX_EXTERN_C extern - #endif +#define __PYX_EXTERN_C extern +#endif #endif #define __PYX_HAVE__total_least_squares @@ -1241,8 +1246,15 @@ static CYTHON_INLINE float __PYX_NAN() { #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; +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 @@ -1252,148 +1264,141 @@ typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* enc #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) +#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) +#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) +#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) +#define __Pyx_sst_abs(value) ((value < 0) ? -value : value) #endif static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); -static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); -static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); -#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) -#define __Pyx_PyBytes_FromString PyBytes_FromString +static CYTHON_INLINE const char *__Pyx_PyObject_AsString(PyObject *); +static CYTHON_INLINE const char *__Pyx_PyObject_AsStringAndSize(PyObject *, Py_ssize_t *length); +static CYTHON_INLINE PyObject *__Pyx_PyByteArray_FromString(const char *); +#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*); +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_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __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) -#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) -#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#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_uintptr_t)__Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char *)(__pyx_uintptr_t)__Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char *)(__pyx_uintptr_t)__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) +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) -static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); -static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); -static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); -#define __Pyx_PySequence_Tuple(obj)\ - (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) -static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); -static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); +static CYTHON_INLINE PyObject *__Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject *); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject *); +static CYTHON_INLINE PyObject *__Pyx_PyNumber_IntOrLong(PyObject *x); +#define __Pyx_PySequence_Tuple(obj) (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject *); +static CYTHON_INLINE PyObject *__Pyx_PyInt_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject *); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif -#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#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 #if CYTHON_USE_PYLONG_INTERNALS - #if PY_VERSION_HEX >= 0x030C00A7 - #ifndef _PyLong_SIGN_MASK - #define _PyLong_SIGN_MASK 3 - #endif - #ifndef _PyLong_NON_SIZE_BITS - #define _PyLong_NON_SIZE_BITS 3 - #endif - #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) - #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) - #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) - #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) - #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) - #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) - #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) - #define __Pyx_PyLong_SignedDigitCount(x)\ - ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) - #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) - #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) - #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) - #else - #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) - #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) - #endif - typedef Py_ssize_t __Pyx_compact_pylong; - typedef size_t __Pyx_compact_upylong; - #else - #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) - #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) - #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) - #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) - #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) - #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) - #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) - #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) - #define __Pyx_PyLong_CompactValue(x)\ - ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) - typedef sdigit __Pyx_compact_pylong; - typedef digit __Pyx_compact_upylong; - #endif - #if PY_VERSION_HEX >= 0x030C00A5 - #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) - #else - #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) - #endif +#if PY_VERSION_HEX >= 0x030C00A7 +#ifndef _PyLong_SIGN_MASK +#define _PyLong_SIGN_MASK 3 +#endif +#ifndef _PyLong_NON_SIZE_BITS +#define _PyLong_NON_SIZE_BITS 3 +#endif +#define __Pyx_PyLong_Sign(x) (((PyLongObject *)x)->long_value.lv_tag & _PyLong_SIGN_MASK) +#define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) +#define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) +#define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) +#define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) +#define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) +#define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t)(((PyLongObject *)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) +#define __Pyx_PyLong_SignedDigitCount(x) ((1 - (Py_ssize_t)__Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) +#if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) +#define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject *)x) +#define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject *)x) +#else +#define __Pyx_PyLong_IsCompact(x) (((PyLongObject *)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) +#define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t)__Pyx_PyLong_Sign(x)) * (Py_ssize_t)__Pyx_PyLong_Digits(x)[0]) +#endif +typedef Py_ssize_t __Pyx_compact_pylong; +typedef size_t __Pyx_compact_upylong; +#else +#define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) +#define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) +#define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) +#define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) +#define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) +#define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) +#define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) +#define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) +#define __Pyx_PyLong_CompactValue(x) \ + ((Py_SIZE(x) == 0) ? (sdigit)0 \ + : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) +typedef sdigit __Pyx_compact_pylong; +typedef digit __Pyx_compact_upylong; +#endif +#if PY_VERSION_HEX >= 0x030C00A5 +#define __Pyx_PyLong_Digits(x) (((PyLongObject *)x)->long_value.ob_digit) +#else +#define __Pyx_PyLong_Digits(x) (((PyLongObject *)x)->ob_digit) +#endif #endif #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII #include 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; + 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); + default_encoding = PyObject_CallMethod(sys, (char *)"getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); @@ -1404,17 +1409,18 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = (char) c; + ascii_chars[c] = (char)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); + 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); @@ -1432,22 +1438,23 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #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) +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) \ + PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #include -static char* __PYX_DEFAULT_STRING_ENCODING; +static char *__PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - char* default_encoding_c; + 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); + 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); + __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); @@ -1459,34 +1466,33 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #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) +#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) +#define likely(x) (x) +#define unlikely(x) (x) #endif /* __GNUC__ */ -static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void *ptr) { (void)ptr; } #if !CYTHON_USE_MODULE_STATE static PyObject *__pyx_m = NULL; #endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm = __FILE__; +static const char *__pyx_cfilenm = __FILE__; static const char *__pyx_filename; /* #### Code section: filename_table ### */ static const char *__pyx_f[] = { - "total_least_squares.pyx", + "total_least_squares.pyx", }; /* #### Code section: utility_code_proto_before_types ### */ /* ForceInitThreads.proto */ #ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 +#define __PYX_FORCE_INIT_THREADS 0 #endif /* #### Code section: numeric_typedefs ### */ @@ -1499,118 +1505,167 @@ static const char *__pyx_f[] = { /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY - #define CYTHON_REFNANNY 0 +#define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY - typedef struct { - void (*INCREF)(void*, PyObject*, Py_ssize_t); - void (*DECREF)(void*, PyObject*, Py_ssize_t); - void (*GOTREF)(void*, PyObject*, Py_ssize_t); - void (*GIVEREF)(void*, PyObject*, Py_ssize_t); - void* (*SetupContext)(const char*, Py_ssize_t, 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; +typedef struct { + void (*INCREF)(void *, PyObject *, Py_ssize_t); + void (*DECREF)(void *, PyObject *, Py_ssize_t); + void (*GOTREF)(void *, PyObject *, Py_ssize_t); + void (*GIVEREF)(void *, PyObject *, Py_ssize_t); + void *(*SetupContext)(const char *, Py_ssize_t, 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__));\ - } - #define __Pyx_RefNannyFinishContextNogil() {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __Pyx_RefNannyFinishContext();\ - PyGILState_Release(__pyx_gilstate_save);\ - } -#else - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) - #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() -#endif - #define __Pyx_RefNannyFinishContextNogil() {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __Pyx_RefNannyFinishContext();\ - PyGILState_Release(__pyx_gilstate_save);\ - } - #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); else {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) -#else - #define __Pyx_RefNannyDeclarations - #define __Pyx_RefNannySetupContext(name, acquire_gil) - #define __Pyx_RefNannyFinishContextNogil() - #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_Py_XDECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; Py_XDECREF(tmp);\ +#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__)); \ + } +#define __Pyx_RefNannyFinishContextNogil() \ + { \ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \ + __Pyx_RefNannyFinishContext(); \ + PyGILState_Release(__pyx_gilstate_save); \ + } +#else +#define __Pyx_RefNannySetupContext(name, acquire_gil) \ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) +#define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() +#endif +#define __Pyx_RefNannyFinishContextNogil() \ + { \ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \ + __Pyx_RefNannyFinishContext(); \ + PyGILState_Release(__pyx_gilstate_save); \ + } +#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) \ + ; \ + else { \ + __Pyx_INCREF(r); \ + } \ + } while (0) +#define __Pyx_XDECREF(r) \ + do { \ + if ((r) == NULL) \ + ; \ + else { \ + __Pyx_DECREF(r); \ + } \ + } while (0) +#define __Pyx_XGOTREF(r) \ + do { \ + if ((r) == NULL) \ + ; \ + else { \ + __Pyx_GOTREF(r); \ + } \ + } while (0) +#define __Pyx_XGIVEREF(r) \ + do { \ + if ((r) == NULL) \ + ; \ + else { \ + __Pyx_GIVEREF(r); \ + } \ + } while (0) +#else +#define __Pyx_RefNannyDeclarations +#define __Pyx_RefNannySetupContext(name, acquire_gil) +#define __Pyx_RefNannyFinishContextNogil() +#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_Py_XDECREF_SET(r, v) \ + do { \ + PyObject *tmp = (PyObject *)r; \ + r = v; \ + Py_XDECREF(tmp); \ + } while (0) +#define __Pyx_XDECREF_SET(r, v) \ + do { \ + PyObject *tmp = (PyObject *)r; \ + r = v; \ + __Pyx_XDECREF(tmp); \ } while (0) -#define __Pyx_XDECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; __Pyx_XDECREF(tmp);\ +#define __Pyx_DECREF_SET(r, v) \ + do { \ + PyObject *tmp = (PyObject *)r; \ + r = v; \ + __Pyx_DECREF(tmp); \ } while (0) -#define __Pyx_DECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; __Pyx_DECREF(tmp);\ +#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) -#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) /* 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); +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState *tstate, PyObject *err); #else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #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_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #if PY_VERSION_HEX >= 0x030C00A6 -#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) -#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() \ + (__pyx_tstate->current_exception ? (PyObject *)Py_TYPE(__pyx_tstate->current_exception) : (PyObject *)NULL) #else -#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) -#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) #endif #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) -#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +#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); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, + PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else @@ -1619,168 +1674,171 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #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) +#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 /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetAttrStr(PyObject *obj, PyObject *attr_name); #else -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#define __Pyx_PyObject_GetAttrStr(o, n) PyObject_GetAttr(o, n) #endif /* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetAttrStrNoError(PyObject *obj, PyObject *attr_name); /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* 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); +#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); /* 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);\ +#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);\ - }\ -} +#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); +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_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); +#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) do {\ - 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);\ -} while(0) -#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ - PY_UINT64_T __pyx_dict_version;\ - PyObject *__pyx_dict_cached_value;\ - (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} while(0) +#define __Pyx_GetModuleGlobalName(var, name) \ + do { \ + 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); \ + } while (0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) \ + do { \ + PY_UINT64_T __pyx_dict_version; \ + PyObject *__pyx_dict_cached_value; \ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value); \ + } while (0) 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) +#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 /* 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; +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); - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 L->ob_item[len] = x; - #else +#else PyList_SET_ITEM(list, len, x); - #endif +#endif __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else -#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#define __Pyx_PyList_Append(L, x) PyList_Append(L, x) #endif /* ListCompAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS -static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { - PyListObject* L = (PyListObject*) list; +static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject *list, PyObject *x) { + PyListObject *L = (PyListObject *)list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len)) { Py_INCREF(x); - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 L->ob_item[len] = x; - #else +#else PyList_SET_ITEM(list, len, x); - #endif +#endif __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else -#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) +#define __Pyx_ListComp_Append(L, x) PyList_Append(L, x) #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #if !CYTHON_VECTORCALL -#define __Pyx_PyFunction_FastCall(func, args, nargs)\ - __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#define __Pyx_PyFunction_FastCall(func, args, nargs) __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); #endif -#define __Pyx_BUILD_ASSERT_EXPR(cond)\ - (sizeof(char [1 - 2*!(cond)]) - 1) +#define __Pyx_BUILD_ASSERT_EXPR(cond) (sizeof(char[1 - 2 * !(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif #if !CYTHON_VECTORCALL #if PY_VERSION_HEX >= 0x03080000 - #include "frameobject.h" +#include "frameobject.h" #if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #ifndef Py_BUILD_CORE - #define Py_BUILD_CORE 1 - #endif - #include "internal/pycore_frame.h" -#endif - #define __Pxy_PyFrame_Initialize_Offsets() - #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) -#else - 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)\ +#ifndef Py_BUILD_CORE +#define Py_BUILD_CORE 1 +#endif +#include "internal/pycore_frame.h" +#endif +#define __Pxy_PyFrame_Initialize_Offsets() +#define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else +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 #endif @@ -1788,99 +1846,102 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +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); +static CYTHON_INLINE PyObject *__Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectFastCall.proto */ -#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) -static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject *__Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, + PyObject *kwargs); /* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); +static CYTHON_INLINE PyObject *__Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* TupleAndListFromArray.proto */ #if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); -static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject *__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject *__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); #endif /* IncludeStringH.proto */ #include /* BytesEquals.proto */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); +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); +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject *s1, PyObject *s2, int equals); /* fastcall.proto */ #if CYTHON_AVOID_BORROWED_REFS - #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) #elif CYTHON_ASSUME_SAFE_MACROS - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) +#define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) #else - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) +#define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) #endif #if CYTHON_AVOID_BORROWED_REFS - #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) - #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) +#define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) #else - #define __Pyx_Arg_NewRef_VARARGS(arg) arg - #define __Pyx_Arg_XDECREF_VARARGS(arg) +#define __Pyx_Arg_NewRef_VARARGS(arg) arg +#define __Pyx_Arg_XDECREF_VARARGS(arg) #endif #define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) #define __Pyx_KwValues_VARARGS(args, nargs) NULL #define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) #define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) #if CYTHON_METH_FASTCALL - #define __Pyx_Arg_FASTCALL(args, i) args[i] - #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) - #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) - static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); +#define __Pyx_Arg_FASTCALL(args, i) args[i] +#define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) +#define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) +static CYTHON_INLINE PyObject *__Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 - CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); - #else - #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) - #endif - #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs - to have the same reference counting */ - #define __Pyx_Arg_XDECREF_FASTCALL(arg) -#else - #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS - #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS - #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS - #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS - #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS - #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) - #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); +#else +#define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) +#endif +#define __Pyx_Arg_NewRef_FASTCALL(arg) \ + arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs \ + to have the same reference counting */ +#define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else +#define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS +#define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS +#define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS +#define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS +#define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS +#define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) +#define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) #endif #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) \ + __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) \ + __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) #else #define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) #define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) #endif /* RaiseDoubleKeywords.proto */ -static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); +static void __Pyx_RaiseDoubleKeywordsError(const char *func_name, PyObject *kw_name); /* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, - const char* function_name); +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, + const char *function_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); +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); /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); @@ -1904,18 +1965,17 @@ static PyObject *__Pyx_FetchSharedCythonABIModule(void); /* FetchCommonType.proto */ #if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +static PyTypeObject *__Pyx_FetchCommonType(PyTypeObject *type); #else -static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); #endif /* PyMethodNew.proto */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { - PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + PyObject *typesModule = NULL, *methodType = NULL, *result = NULL; CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); + if (!self) return __Pyx_NewRef(func); typesModule = PyImport_ImportModule("types"); if (!typesModule) return NULL; methodType = PyObject_GetAttrString(typesModule, "MethodType"); @@ -1928,44 +1988,38 @@ static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *ty #elif PY_MAJOR_VERSION >= 3 static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); + if (!self) return __Pyx_NewRef(func); return PyMethod_New(func, self); } #else - #define __Pyx_PyMethod_New PyMethod_New +#define __Pyx_PyMethod_New PyMethod_New #endif /* PyVectorcallFastCallDict.proto */ #if CYTHON_METH_FASTCALL -static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, + PyObject *const *args, size_t nargs, PyObject *kw); #endif /* CythonFunctionShared.proto */ #define __Pyx_CyFunction_USED -#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 -#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 -#define __Pyx_CYFUNCTION_CCLASS 0x04 -#define __Pyx_CYFUNCTION_COROUTINE 0x08 -#define __Pyx_CyFunction_GetClosure(f)\ - (((__pyx_CyFunctionObject *) (f))->func_closure) +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f) (((__pyx_CyFunctionObject *)(f))->func_closure) #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_CyFunction_GetClassObj(f)\ - (((__pyx_CyFunctionObject *) (f))->func_classobj) -#else - #define __Pyx_CyFunction_GetClassObj(f)\ - ((PyObject*) ((PyCMethodObject *) (f))->mm_class) -#endif -#define __Pyx_CyFunction_SetClassObj(f, classobj)\ - __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) -#define __Pyx_CyFunction_Defaults(type, f)\ - ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) -#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ - ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +#define __Pyx_CyFunction_GetClassObj(f) (((__pyx_CyFunctionObject *)(f))->func_classobj) +#else +#define __Pyx_CyFunction_GetClassObj(f) ((PyObject *)((PyCMethodObject *)(f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj) \ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *)(f), (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 { #if CYTHON_COMPILING_IN_LIMITED_API - PyObject_HEAD - PyObject *func; + PyObject_HEAD PyObject *func; #elif PY_VERSION_HEX < 0x030900B1 PyCFunctionObject func; #else @@ -1998,50 +2052,42 @@ typedef struct { PyObject *func_is_coroutine; } __pyx_CyFunctionObject; #undef __Pyx_CyOrPyCFunction_Check -#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) -#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) -#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); #undef __Pyx_IsSameCFunction -#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) -static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, - int flags, PyObject* qualname, - PyObject *closure, - PyObject *module, PyObject *globals, - PyObject* code); -static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); -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); +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject *qualname, + PyObject *closure, PyObject *module, PyObject *globals, PyObject *code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject *f, PyObject *classobj); +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(PyObject *module); #if CYTHON_METH_FASTCALL -static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject *__Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, + PyObject *kwnames); +static PyObject *__Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject *__Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, + PyObject *kwnames); +static PyObject *__Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, + size_t nargsf, PyObject *kwnames); #if CYTHON_BACKPORT_VECTORCALL -#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject *)f)->func_vectorcall) #else -#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject *)f)->vectorcall) #endif #endif /* CythonFunction.proto */ -static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, - int flags, PyObject* qualname, - PyObject *closure, - PyObject *module, PyObject *globals, - PyObject* code); +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject *qualname, PyObject *closure, + PyObject *module, PyObject *globals, PyObject *code); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK -#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif @@ -2049,23 +2095,22 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); /* CodeObjectCache.proto */ #if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { - PyCodeObject* code_object; + PyCodeObject *code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; - __Pyx_CodeObjectCacheEntry* entries; + __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 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); +static void __pyx_insert_code_object(int code_line, PyCodeObject *code_object); #endif /* AddTraceback.proto */ -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename); +static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* GCCDiagnostics.proto */ #if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) @@ -2073,19 +2118,19 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, #endif /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); +static CYTHON_INLINE PyObject *__Pyx_PyInt_From_int(int value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); +static CYTHON_INLINE PyObject *__Pyx_PyInt_From_long(long value); /* FormatTypeName.proto */ #if CYTHON_COMPILING_IN_LIMITED_API typedef PyObject *__Pyx_TypeName; #define __Pyx_FMT_TYPENAME "%U" -static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject *tp); #define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) #else typedef const char *__Pyx_TypeName; @@ -2100,18 +2145,22 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) -#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) +#define __Pyx_TypeCheck2(obj, type1, type2) \ + __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, 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_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) +#define __Pyx_TypeCheck2(obj, type1, type2) \ + (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #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)) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) \ + (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif -#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) \ + __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ @@ -2126,19 +2175,19 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from "libc.math" */ /* Module declarations from "total_least_squares" */ -static float __pyx_f_19total_least_squares_get_point_var(int, int, float, float); /*proto*/ -static float __pyx_f_19total_least_squares_get_theta(float, float); /*proto*/ -static PyObject *__pyx_f_19total_least_squares_get_theta_vector(PyObject *, int); /*proto*/ -static PyObject *__pyx_f_19total_least_squares_get_rho(float, float); /*proto*/ -static PyObject *__pyx_f_19total_least_squares_get_rho_vector(PyObject *, int); /*proto*/ -static PyObject *__pyx_f_19total_least_squares_get_weights(PyObject *, int, float, float); /*proto*/ +static float __pyx_f_19total_least_squares_get_point_var(int, int, float, float); /*proto*/ +static float __pyx_f_19total_least_squares_get_theta(float, float); /*proto*/ +static PyObject *__pyx_f_19total_least_squares_get_theta_vector(PyObject *, int); /*proto*/ +static PyObject *__pyx_f_19total_least_squares_get_rho(float, float); /*proto*/ +static PyObject *__pyx_f_19total_least_squares_get_rho_vector(PyObject *, int); /*proto*/ +static PyObject *__pyx_f_19total_least_squares_get_weights(PyObject *, int, float, float); /*proto*/ static float __pyx_f_19total_least_squares_get_x_weight(PyObject *, PyObject *, PyObject *, PyObject *, int); /*proto*/ static float __pyx_f_19total_least_squares_get_y_weight(PyObject *, PyObject *, PyObject *, PyObject *, int); /*proto*/ -static float __pyx_f_19total_least_squares_get_alpha(PyObject *, int, PyObject *, float, float); /*proto*/ -static float __pyx_f_19total_least_squares_get_r(float, float, float); /*proto*/ -static float __pyx_f_19total_least_squares_get_m(float, float); /*proto*/ -static PyObject *__pyx_f_19total_least_squares_get_b(PyObject *, int, float, float, float); /*proto*/ -static PyObject *__pyx_f_19total_least_squares_fit_line(PyObject *, int __pyx_skip_dispatch); /*proto*/ +static float __pyx_f_19total_least_squares_get_alpha(PyObject *, int, PyObject *, float, float); /*proto*/ +static float __pyx_f_19total_least_squares_get_r(float, float, float); /*proto*/ +static float __pyx_f_19total_least_squares_get_m(float, float); /*proto*/ +static PyObject *__pyx_f_19total_least_squares_get_b(PyObject *, int, float, float, float); /*proto*/ +static PyObject *__pyx_f_19total_least_squares_fit_line(PyObject *, int __pyx_skip_dispatch); /*proto*/ /* #### Code section: typeinfo ### */ /* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "total_least_squares" @@ -2170,67 +2219,68 @@ static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_total_least_squares[] = "total_least_squares"; static const char __pyx_k_total_least_squares_pyx[] = "total_least_squares.pyx"; /* #### Code section: decls ### */ -static PyObject *__pyx_pf_19total_least_squares_fit_line(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_points); /* proto */ +static PyObject *__pyx_pf_19total_least_squares_fit_line(CYTHON_UNUSED PyObject *__pyx_self, + PyObject *__pyx_v_points); /* proto */ /* #### Code section: late_includes ### */ /* #### Code section: module_state ### */ typedef struct { - PyObject *__pyx_d; - PyObject *__pyx_b; - PyObject *__pyx_cython_runtime; - PyObject *__pyx_empty_tuple; - PyObject *__pyx_empty_bytes; - PyObject *__pyx_empty_unicode; - #ifdef __Pyx_CyFunction_USED - PyTypeObject *__pyx_CyFunctionType; - #endif - #ifdef __Pyx_FusedFunction_USED - PyTypeObject *__pyx_FusedFunctionType; - #endif - #ifdef __Pyx_Generator_USED - PyTypeObject *__pyx_GeneratorType; - #endif - #ifdef __Pyx_IterableCoroutine_USED - PyTypeObject *__pyx_IterableCoroutineType; - #endif - #ifdef __Pyx_Coroutine_USED - PyTypeObject *__pyx_CoroutineAwaitType; - #endif - #ifdef __Pyx_Coroutine_USED - PyTypeObject *__pyx_CoroutineType; - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - PyObject *__pyx_n_s_; - PyObject *__pyx_n_s__4; - PyObject *__pyx_n_s_asyncio_coroutines; - PyObject *__pyx_n_s_cline_in_traceback; - PyObject *__pyx_n_s_fit_line; - PyObject *__pyx_n_s_import; - PyObject *__pyx_n_s_initializing; - PyObject *__pyx_n_s_is_coroutine; - PyObject *__pyx_n_s_main; - PyObject *__pyx_n_s_maxsize; - PyObject *__pyx_n_s_name; - PyObject *__pyx_n_s_points; - PyObject *__pyx_n_s_range; - PyObject *__pyx_n_s_spec; - PyObject *__pyx_n_s_sum; - PyObject *__pyx_n_s_sys; - PyObject *__pyx_n_s_test; - PyObject *__pyx_n_s_total_least_squares; - PyObject *__pyx_kp_s_total_least_squares_pyx; - PyObject *__pyx_int_1; - PyObject *__pyx_int_2; - PyObject *__pyx_tuple__2; - PyObject *__pyx_codeobj__3; + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; +#ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; +#endif +#ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; +#endif +#ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; +#endif +#ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; +#endif +#ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; +#endif +#ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif + PyObject *__pyx_n_s_; + PyObject *__pyx_n_s__4; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_s_fit_line; + PyObject *__pyx_n_s_import; + PyObject *__pyx_n_s_initializing; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_maxsize; + PyObject *__pyx_n_s_name; + PyObject *__pyx_n_s_points; + PyObject *__pyx_n_s_range; + PyObject *__pyx_n_s_spec; + PyObject *__pyx_n_s_sum; + PyObject *__pyx_n_s_sys; + PyObject *__pyx_n_s_test; + PyObject *__pyx_n_s_total_least_squares; + PyObject *__pyx_kp_s_total_least_squares_pyx; + PyObject *__pyx_int_1; + PyObject *__pyx_int_2; + PyObject *__pyx_tuple__2; + PyObject *__pyx_codeobj__3; } __pyx_mstate; #if CYTHON_USE_MODULE_STATE #ifdef __cplusplus namespace { - extern struct PyModuleDef __pyx_moduledef; +extern struct PyModuleDef __pyx_moduledef; } /* anonymous namespace */ #else static struct PyModuleDef __pyx_moduledef; @@ -2253,87 +2303,87 @@ static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; /* #### Code section: module_state_clear ### */ #if CYTHON_USE_MODULE_STATE static int __pyx_m_clear(PyObject *m) { - __pyx_mstate *clear_module_state = __pyx_mstate(m); - if (!clear_module_state) return 0; - Py_CLEAR(clear_module_state->__pyx_d); - Py_CLEAR(clear_module_state->__pyx_b); - Py_CLEAR(clear_module_state->__pyx_cython_runtime); - Py_CLEAR(clear_module_state->__pyx_empty_tuple); - Py_CLEAR(clear_module_state->__pyx_empty_bytes); - Py_CLEAR(clear_module_state->__pyx_empty_unicode); - #ifdef __Pyx_CyFunction_USED - Py_CLEAR(clear_module_state->__pyx_CyFunctionType); - #endif - #ifdef __Pyx_FusedFunction_USED - Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); - #endif - Py_CLEAR(clear_module_state->__pyx_n_s_); - Py_CLEAR(clear_module_state->__pyx_n_s__4); - Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); - Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); - Py_CLEAR(clear_module_state->__pyx_n_s_fit_line); - Py_CLEAR(clear_module_state->__pyx_n_s_import); - Py_CLEAR(clear_module_state->__pyx_n_s_initializing); - Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); - Py_CLEAR(clear_module_state->__pyx_n_s_main); - Py_CLEAR(clear_module_state->__pyx_n_s_maxsize); - Py_CLEAR(clear_module_state->__pyx_n_s_name); - Py_CLEAR(clear_module_state->__pyx_n_s_points); - Py_CLEAR(clear_module_state->__pyx_n_s_range); - Py_CLEAR(clear_module_state->__pyx_n_s_spec); - Py_CLEAR(clear_module_state->__pyx_n_s_sum); - Py_CLEAR(clear_module_state->__pyx_n_s_sys); - Py_CLEAR(clear_module_state->__pyx_n_s_test); - Py_CLEAR(clear_module_state->__pyx_n_s_total_least_squares); - Py_CLEAR(clear_module_state->__pyx_kp_s_total_least_squares_pyx); - Py_CLEAR(clear_module_state->__pyx_int_1); - Py_CLEAR(clear_module_state->__pyx_int_2); - Py_CLEAR(clear_module_state->__pyx_tuple__2); - Py_CLEAR(clear_module_state->__pyx_codeobj__3); - return 0; + __pyx_mstate *clear_module_state = __pyx_mstate(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); +#ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); +#endif +#ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); +#endif + Py_CLEAR(clear_module_state->__pyx_n_s_); + Py_CLEAR(clear_module_state->__pyx_n_s__4); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_fit_line); + Py_CLEAR(clear_module_state->__pyx_n_s_import); + Py_CLEAR(clear_module_state->__pyx_n_s_initializing); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_maxsize); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_n_s_points); + Py_CLEAR(clear_module_state->__pyx_n_s_range); + Py_CLEAR(clear_module_state->__pyx_n_s_spec); + Py_CLEAR(clear_module_state->__pyx_n_s_sum); + Py_CLEAR(clear_module_state->__pyx_n_s_sys); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_n_s_total_least_squares); + Py_CLEAR(clear_module_state->__pyx_kp_s_total_least_squares_pyx); + Py_CLEAR(clear_module_state->__pyx_int_1); + Py_CLEAR(clear_module_state->__pyx_int_2); + Py_CLEAR(clear_module_state->__pyx_tuple__2); + Py_CLEAR(clear_module_state->__pyx_codeobj__3); + return 0; } #endif /* #### Code section: module_state_traverse ### */ #if CYTHON_USE_MODULE_STATE static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { - __pyx_mstate *traverse_module_state = __pyx_mstate(m); - if (!traverse_module_state) return 0; - Py_VISIT(traverse_module_state->__pyx_d); - Py_VISIT(traverse_module_state->__pyx_b); - Py_VISIT(traverse_module_state->__pyx_cython_runtime); - Py_VISIT(traverse_module_state->__pyx_empty_tuple); - Py_VISIT(traverse_module_state->__pyx_empty_bytes); - Py_VISIT(traverse_module_state->__pyx_empty_unicode); - #ifdef __Pyx_CyFunction_USED - Py_VISIT(traverse_module_state->__pyx_CyFunctionType); - #endif - #ifdef __Pyx_FusedFunction_USED - Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); - #endif - Py_VISIT(traverse_module_state->__pyx_n_s_); - Py_VISIT(traverse_module_state->__pyx_n_s__4); - Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); - Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); - Py_VISIT(traverse_module_state->__pyx_n_s_fit_line); - Py_VISIT(traverse_module_state->__pyx_n_s_import); - Py_VISIT(traverse_module_state->__pyx_n_s_initializing); - Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); - Py_VISIT(traverse_module_state->__pyx_n_s_main); - Py_VISIT(traverse_module_state->__pyx_n_s_maxsize); - Py_VISIT(traverse_module_state->__pyx_n_s_name); - Py_VISIT(traverse_module_state->__pyx_n_s_points); - Py_VISIT(traverse_module_state->__pyx_n_s_range); - Py_VISIT(traverse_module_state->__pyx_n_s_spec); - Py_VISIT(traverse_module_state->__pyx_n_s_sum); - Py_VISIT(traverse_module_state->__pyx_n_s_sys); - Py_VISIT(traverse_module_state->__pyx_n_s_test); - Py_VISIT(traverse_module_state->__pyx_n_s_total_least_squares); - Py_VISIT(traverse_module_state->__pyx_kp_s_total_least_squares_pyx); - Py_VISIT(traverse_module_state->__pyx_int_1); - Py_VISIT(traverse_module_state->__pyx_int_2); - Py_VISIT(traverse_module_state->__pyx_tuple__2); - Py_VISIT(traverse_module_state->__pyx_codeobj__3); - return 0; + __pyx_mstate *traverse_module_state = __pyx_mstate(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(traverse_module_state->__pyx_empty_unicode); +#ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); +#endif +#ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); +#endif + Py_VISIT(traverse_module_state->__pyx_n_s_); + Py_VISIT(traverse_module_state->__pyx_n_s__4); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_fit_line); + Py_VISIT(traverse_module_state->__pyx_n_s_import); + Py_VISIT(traverse_module_state->__pyx_n_s_initializing); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_maxsize); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_n_s_points); + Py_VISIT(traverse_module_state->__pyx_n_s_range); + Py_VISIT(traverse_module_state->__pyx_n_s_spec); + Py_VISIT(traverse_module_state->__pyx_n_s_sum); + Py_VISIT(traverse_module_state->__pyx_n_s_sys); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_n_s_total_least_squares); + Py_VISIT(traverse_module_state->__pyx_kp_s_total_least_squares_pyx); + Py_VISIT(traverse_module_state->__pyx_int_1); + Py_VISIT(traverse_module_state->__pyx_int_2); + Py_VISIT(traverse_module_state->__pyx_tuple__2); + Py_VISIT(traverse_module_state->__pyx_codeobj__3); + return 0; } #endif /* #### Code section: module_state_defines ### */ @@ -2391,37 +2441,39 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { /* #### Code section: module_code ### */ /* "total_least_squares.pyx":7 - * + * * # Point Wise Variance * cdef float get_point_var(int x, int y, float x_mean, float y_mean): # <<<<<<<<<<<<<< * # point_x_var = (x - x_mean)**2 * # point_y_var = (y - y_mean)**2 */ -static float __pyx_f_19total_least_squares_get_point_var(CYTHON_UNUSED int __pyx_v_x, CYTHON_UNUSED int __pyx_v_y, CYTHON_UNUSED float __pyx_v_x_mean, CYTHON_UNUSED float __pyx_v_y_mean) { - float __pyx_r; - - /* "total_least_squares.pyx":11 - * # point_y_var = (y - y_mean)**2 - * # return (point_x_var + point_y_var) / 2 - * return 1.0 # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = 1.0; - goto __pyx_L0; +static float __pyx_f_19total_least_squares_get_point_var(CYTHON_UNUSED int __pyx_v_x, CYTHON_UNUSED int __pyx_v_y, + CYTHON_UNUSED float __pyx_v_x_mean, + CYTHON_UNUSED float __pyx_v_y_mean) { + float __pyx_r; + + /* "total_least_squares.pyx":11 + * # point_y_var = (y - y_mean)**2 + * # return (point_x_var + point_y_var) / 2 + * return 1.0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 1.0; + goto __pyx_L0; - /* "total_least_squares.pyx":7 - * +/* "total_least_squares.pyx":7 + * * # Point Wise Variance * cdef float get_point_var(int x, int y, float x_mean, float y_mean): # <<<<<<<<<<<<<< * # point_x_var = (x - x_mean)**2 * # point_y_var = (y - y_mean)**2 */ - /* function exit code */ - __pyx_L0:; - return __pyx_r; +/* function exit code */ +__pyx_L0:; + return __pyx_r; } /* "total_least_squares.pyx":16 @@ -2432,172 +2484,205 @@ static float __pyx_f_19total_least_squares_get_point_var(CYTHON_UNUSED int __pyx * cdef float y_sample_var = 0 */ -static PyObject *__pyx_f_19total_least_squares_get_sample_vars(PyObject *__pyx_v_points, float __pyx_v_x_mean, float __pyx_v_y_mean, int __pyx_v_num_points) { - float __pyx_v_x_sample_var; - float __pyx_v_y_sample_var; - int __pyx_v_i; - 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; - float __pyx_t_8; - long __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_sample_vars", 1); - - /* "total_least_squares.pyx":17 - * # Sample Variances - * cdef get_sample_vars(points, float x_mean, float y_mean, int num_points): - * cdef float x_sample_var = 0 # <<<<<<<<<<<<<< - * cdef float y_sample_var = 0 - * cdef int i - */ - __pyx_v_x_sample_var = 0.0; - - /* "total_least_squares.pyx":18 - * cdef get_sample_vars(points, float x_mean, float y_mean, int num_points): - * cdef float x_sample_var = 0 - * cdef float y_sample_var = 0 # <<<<<<<<<<<<<< - * cdef int i - * - */ - __pyx_v_y_sample_var = 0.0; - - /* "total_least_squares.pyx":21 - * cdef int i - * - * for i in range(num_points): # <<<<<<<<<<<<<< - * x_sample_var += (points[i][0] - x_mean)**2 - * y_sample_var += (points[i][1] - y_mean)**2 - */ - __pyx_t_1 = __pyx_v_num_points; - __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; - - /* "total_least_squares.pyx":22 - * - * for i in range(num_points): - * x_sample_var += (points[i][0] - x_mean)**2 # <<<<<<<<<<<<<< - * y_sample_var += (points[i][1] - y_mean)**2 - * - */ - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_x_sample_var); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 22, __pyx_L1_error) +static PyObject *__pyx_f_19total_least_squares_get_sample_vars(PyObject *__pyx_v_points, float __pyx_v_x_mean, + float __pyx_v_y_mean, int __pyx_v_num_points) { + float __pyx_v_x_sample_var; + float __pyx_v_y_sample_var; + int __pyx_v_i; + 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; + float __pyx_t_8; + long __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_sample_vars", 1); + + /* "total_least_squares.pyx":17 + * # Sample Variances + * cdef get_sample_vars(points, float x_mean, float y_mean, int num_points): + * cdef float x_sample_var = 0 # <<<<<<<<<<<<<< + * cdef float y_sample_var = 0 + * cdef int i + */ + __pyx_v_x_sample_var = 0.0; + + /* "total_least_squares.pyx":18 + * cdef get_sample_vars(points, float x_mean, float y_mean, int num_points): + * cdef float x_sample_var = 0 + * cdef float y_sample_var = 0 # <<<<<<<<<<<<<< + * cdef int i + * + */ + __pyx_v_y_sample_var = 0.0; + + /* "total_least_squares.pyx":21 + * cdef int i + * + * for i in range(num_points): # <<<<<<<<<<<<<< + * x_sample_var += (points[i][0] - x_mean)**2 + * y_sample_var += (points[i][1] - y_mean)**2 + */ + __pyx_t_1 = __pyx_v_num_points; + __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; + + /* "total_least_squares.pyx":22 + * + * for i in range(num_points): + * x_sample_var += (points[i][0] - x_mean)**2 # <<<<<<<<<<<<<< + * y_sample_var += (points[i][1] - y_mean)**2 + * + */ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_x_sample_var); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_x_mean); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = PyNumber_Subtract(__pyx_t_6, __pyx_t_5); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Power(__pyx_t_7, __pyx_int_2, Py_None); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_5); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_8 = __pyx_PyFloat_AsFloat(__pyx_t_7); + if (unlikely((__pyx_t_8 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = 0; + __pyx_v_x_sample_var = __pyx_t_8; + + /* "total_least_squares.pyx":23 + * for i in range(num_points): + * x_sample_var += (points[i][0] - x_mean)**2 + * y_sample_var += (points[i][1] - y_mean)**2 # <<<<<<<<<<<<<< + * + * x_sample_var = x_sample_var / (num_points - 1) + */ + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_y_sample_var); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_y_mean); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 23, __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, 23, __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, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = PyNumber_InPlaceAdd(__pyx_t_7, __pyx_t_5); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_8 = __pyx_PyFloat_AsFloat(__pyx_t_6); + if (unlikely((__pyx_t_8 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __pyx_v_y_sample_var = __pyx_t_8; + } + + /* "total_least_squares.pyx":25 + * y_sample_var += (points[i][1] - y_mean)**2 + * + * x_sample_var = x_sample_var / (num_points - 1) # <<<<<<<<<<<<<< + * y_sample_var = y_sample_var / (num_points - 1) + * + */ + __pyx_t_9 = (__pyx_v_num_points - 1); + if (unlikely(__pyx_t_9 == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(0, 25, __pyx_L1_error) + } + __pyx_v_x_sample_var = (__pyx_v_x_sample_var / ((float)__pyx_t_9)); + + /* "total_least_squares.pyx":26 + * + * x_sample_var = x_sample_var / (num_points - 1) + * y_sample_var = y_sample_var / (num_points - 1) # <<<<<<<<<<<<<< + * + * return [x_sample_var, y_sample_var] + */ + __pyx_t_9 = (__pyx_v_num_points - 1); + if (unlikely(__pyx_t_9 == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(0, 26, __pyx_L1_error) + } + __pyx_v_y_sample_var = (__pyx_v_y_sample_var / ((float)__pyx_t_9)); + + /* "total_least_squares.pyx":28 + * y_sample_var = y_sample_var / (num_points - 1) + * + * return [x_sample_var, y_sample_var] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_x_sample_var); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_x_mean); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = PyNumber_Subtract(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyNumber_Power(__pyx_t_7, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error) + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_y_sample_var); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = __pyx_PyFloat_AsFloat(__pyx_t_7); if (unlikely((__pyx_t_8 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_x_sample_var = __pyx_t_8; - - /* "total_least_squares.pyx":23 - * for i in range(num_points): - * x_sample_var += (points[i][0] - x_mean)**2 - * y_sample_var += (points[i][1] - y_mean)**2 # <<<<<<<<<<<<<< - * - * x_sample_var = x_sample_var / (num_points - 1) - */ - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_y_sample_var); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 23, __pyx_L1_error) + __pyx_t_7 = PyList_New(2); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 23, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 23, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_y_mean); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 23, __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, 23, __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, 23, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyNumber_InPlaceAdd(__pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 23, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = __pyx_PyFloat_AsFloat(__pyx_t_6); if (unlikely((__pyx_t_8 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 23, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_v_y_sample_var = __pyx_t_8; - } - - /* "total_least_squares.pyx":25 - * y_sample_var += (points[i][1] - y_mean)**2 - * - * x_sample_var = x_sample_var / (num_points - 1) # <<<<<<<<<<<<<< - * y_sample_var = y_sample_var / (num_points - 1) - * - */ - __pyx_t_9 = (__pyx_v_num_points - 1); - if (unlikely(__pyx_t_9 == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "float division"); - __PYX_ERR(0, 25, __pyx_L1_error) - } - __pyx_v_x_sample_var = (__pyx_v_x_sample_var / ((float)__pyx_t_9)); - - /* "total_least_squares.pyx":26 - * - * x_sample_var = x_sample_var / (num_points - 1) - * y_sample_var = y_sample_var / (num_points - 1) # <<<<<<<<<<<<<< - * - * return [x_sample_var, y_sample_var] - */ - __pyx_t_9 = (__pyx_v_num_points - 1); - if (unlikely(__pyx_t_9 == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "float division"); - __PYX_ERR(0, 26, __pyx_L1_error) - } - __pyx_v_y_sample_var = (__pyx_v_y_sample_var / ((float)__pyx_t_9)); - - /* "total_least_squares.pyx":28 - * y_sample_var = y_sample_var / (num_points - 1) - * - * return [x_sample_var, y_sample_var] # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_6 = PyFloat_FromDouble(__pyx_v_x_sample_var); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 28, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_y_sample_var); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 28, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = PyList_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 28, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_t_6)) __PYX_ERR(0, 28, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_t_5)) __PYX_ERR(0, 28, __pyx_L1_error); - __pyx_t_6 = 0; - __pyx_t_5 = 0; - __pyx_r = __pyx_t_7; - __pyx_t_7 = 0; - goto __pyx_L0; - - /* "total_least_squares.pyx":16 + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_t_6)) __PYX_ERR(0, 28, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_t_5)) __PYX_ERR(0, 28, __pyx_L1_error); + __pyx_t_6 = 0; + __pyx_t_5 = 0; + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L0; + +/* "total_least_squares.pyx":16 * # Unused * # Sample Variances * cdef get_sample_vars(points, float x_mean, float y_mean, int num_points): # <<<<<<<<<<<<<< @@ -2605,22 +2690,22 @@ static PyObject *__pyx_f_19total_least_squares_get_sample_vars(PyObject *__pyx_v * cdef float y_sample_var = 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("total_least_squares.get_sample_vars", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; +/* 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("total_least_squares.get_sample_vars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; +__pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } /* "total_least_squares.pyx":32 - * + * * # Theta * cdef float get_theta(float x, float y): # <<<<<<<<<<<<<< * if x == 0: @@ -2628,97 +2713,100 @@ static PyObject *__pyx_f_19total_least_squares_get_sample_vars(PyObject *__pyx_v */ static float __pyx_f_19total_least_squares_get_theta(float __pyx_v_x, float __pyx_v_y) { - float __pyx_v_theta; - float __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - float __pyx_t_4; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_theta", 1); - - /* "total_least_squares.pyx":33 - * # Theta - * cdef float get_theta(float x, float y): - * if x == 0: # <<<<<<<<<<<<<< - * x = sys.maxsize - * - */ - __pyx_t_1 = (__pyx_v_x == 0.0); - if (__pyx_t_1) { - - /* "total_least_squares.pyx":34 - * cdef float get_theta(float x, float y): - * if x == 0: - * x = sys.maxsize # <<<<<<<<<<<<<< - * - * cdef float theta = math.atan(y / x) - */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_maxsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_x = __pyx_t_4; + float __pyx_v_theta; + float __pyx_r; + __Pyx_RefNannyDeclarations int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + float __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_theta", 1); /* "total_least_squares.pyx":33 - * # Theta - * cdef float get_theta(float x, float y): - * if x == 0: # <<<<<<<<<<<<<< - * x = sys.maxsize - * - */ - } - - /* "total_least_squares.pyx":36 - * x = sys.maxsize - * - * cdef float theta = math.atan(y / x) # <<<<<<<<<<<<<< - * return theta - * - */ - if (unlikely(__pyx_v_x == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "float division"); - __PYX_ERR(0, 36, __pyx_L1_error) - } - __pyx_v_theta = atan((__pyx_v_y / __pyx_v_x)); - - /* "total_least_squares.pyx":37 - * - * cdef float theta = math.atan(y / x) - * return theta # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_theta; - goto __pyx_L0; + * # Theta + * cdef float get_theta(float x, float y): + * if x == 0: # <<<<<<<<<<<<<< + * x = sys.maxsize + * + */ + __pyx_t_1 = (__pyx_v_x == 0.0); + if (__pyx_t_1) { + /* "total_least_squares.pyx":34 + * cdef float get_theta(float x, float y): + * if x == 0: + * x = sys.maxsize # <<<<<<<<<<<<<< + * + * cdef float theta = math.atan(y / x) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_sys); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_maxsize); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_3); + if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = 0; + __pyx_v_x = __pyx_t_4; + + /* "total_least_squares.pyx":33 + * # Theta + * cdef float get_theta(float x, float y): + * if x == 0: # <<<<<<<<<<<<<< + * x = sys.maxsize + * + */ + } + + /* "total_least_squares.pyx":36 + * x = sys.maxsize + * + * cdef float theta = math.atan(y / x) # <<<<<<<<<<<<<< + * return theta + * + */ + if (unlikely(__pyx_v_x == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(0, 36, __pyx_L1_error) + } + __pyx_v_theta = atan((__pyx_v_y / __pyx_v_x)); + + /* "total_least_squares.pyx":37 + * + * cdef float theta = math.atan(y / x) + * return theta # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_theta; + goto __pyx_L0; - /* "total_least_squares.pyx":32 - * +/* "total_least_squares.pyx":32 + * * # Theta * cdef float get_theta(float x, float y): # <<<<<<<<<<<<<< * if x == 0: * x = sys.maxsize */ - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("total_least_squares.get_theta", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; +/* function exit code */ +__pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("total_least_squares.get_theta", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; +__pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; } /* "total_least_squares.pyx":41 - * + * * # Theta Vector * cdef get_theta_vector(points, int num_points): # <<<<<<<<<<<<<< * theta_mat = [] @@ -2726,111 +2814,125 @@ static float __pyx_f_19total_least_squares_get_theta(float __pyx_v_x, float __py */ static PyObject *__pyx_f_19total_least_squares_get_theta_vector(PyObject *__pyx_v_points, int __pyx_v_num_points) { - PyObject *__pyx_v_theta_mat = NULL; - int __pyx_v_i; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - float __pyx_t_6; - float __pyx_t_7; - float __pyx_t_8; - int __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_theta_vector", 1); - - /* "total_least_squares.pyx":42 - * # Theta Vector - * cdef get_theta_vector(points, int num_points): - * theta_mat = [] # <<<<<<<<<<<<<< - * cdef int i - * - */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_theta_mat = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "total_least_squares.pyx":45 - * cdef int i - * - * for i in range(num_points): # <<<<<<<<<<<<<< - * theta_mat.append(get_theta(points[i][0], points[i][1])) - * - */ - __pyx_t_2 = __pyx_v_num_points; - __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; - - /* "total_least_squares.pyx":46 - * - * for i in range(num_points): - * theta_mat.append(get_theta(points[i][0], points[i][1])) # <<<<<<<<<<<<<< - * - * return theta_mat - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) + PyObject *__pyx_v_theta_mat = NULL; + int __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + float __pyx_t_6; + float __pyx_t_7; + float __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_theta_vector", 1); + + /* "total_least_squares.pyx":42 + * # Theta Vector + * cdef get_theta_vector(points, int num_points): + * theta_mat = [] # <<<<<<<<<<<<<< + * cdef int i + * + */ + __pyx_t_1 = PyList_New(0); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_7 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_7 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_8 = __pyx_f_19total_least_squares_get_theta(__pyx_t_6, __pyx_t_7); if (unlikely(__pyx_t_8 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 46, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble(__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_theta_mat, __pyx_t_1); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } - - /* "total_least_squares.pyx":48 - * theta_mat.append(get_theta(points[i][0], points[i][1])) - * - * return theta_mat # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_theta_mat); - __pyx_r = __pyx_v_theta_mat; - goto __pyx_L0; + __pyx_v_theta_mat = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "total_least_squares.pyx":45 + * cdef int i + * + * for i in range(num_points): # <<<<<<<<<<<<<< + * theta_mat.append(get_theta(points[i][0], points[i][1])) + * + */ + __pyx_t_2 = __pyx_v_num_points; + __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; + + /* "total_least_squares.pyx":46 + * + * for i in range(num_points): + * theta_mat.append(get_theta(points[i][0], points[i][1])) # <<<<<<<<<<<<<< + * + * return theta_mat + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); + if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_7 = __pyx_PyFloat_AsFloat(__pyx_t_1); + if (unlikely((__pyx_t_7 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_8 = __pyx_f_19total_least_squares_get_theta(__pyx_t_6, __pyx_t_7); + if (unlikely(__pyx_t_8 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 46, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_t_8); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_theta_mat, __pyx_t_1); + if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); + __pyx_t_1 = 0; + } + + /* "total_least_squares.pyx":48 + * theta_mat.append(get_theta(points[i][0], points[i][1])) + * + * return theta_mat # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_theta_mat); + __pyx_r = __pyx_v_theta_mat; + goto __pyx_L0; - /* "total_least_squares.pyx":41 - * +/* "total_least_squares.pyx":41 + * * # Theta Vector * cdef get_theta_vector(points, int num_points): # <<<<<<<<<<<<<< * theta_mat = [] * cdef int i */ - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("total_least_squares.get_theta_vector", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_theta_mat); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; +/* function exit code */ +__pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("total_least_squares.get_theta_vector", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; +__pyx_L0:; + __Pyx_XDECREF(__pyx_v_theta_mat); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } /* "total_least_squares.pyx":52 - * + * * # Rho * cdef get_rho(float x, float y): # <<<<<<<<<<<<<< * rho = math.sqrt(x**2 + y**2) @@ -2838,59 +2940,59 @@ static PyObject *__pyx_f_19total_least_squares_get_theta_vector(PyObject *__pyx_ */ static PyObject *__pyx_f_19total_least_squares_get_rho(float __pyx_v_x, float __pyx_v_y) { - double __pyx_v_rho; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_rho", 1); - - /* "total_least_squares.pyx":53 - * # Rho - * cdef get_rho(float x, float y): - * rho = math.sqrt(x**2 + y**2) # <<<<<<<<<<<<<< - * return rho - * - */ - __pyx_v_rho = sqrt((powf(__pyx_v_x, 2.0) + powf(__pyx_v_y, 2.0))); + double __pyx_v_rho; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_rho", 1); + + /* "total_least_squares.pyx":53 + * # Rho + * cdef get_rho(float x, float y): + * rho = math.sqrt(x**2 + y**2) # <<<<<<<<<<<<<< + * return rho + * + */ + __pyx_v_rho = sqrt((powf(__pyx_v_x, 2.0) + powf(__pyx_v_y, 2.0))); + + /* "total_least_squares.pyx":54 + * cdef get_rho(float x, float y): + * rho = math.sqrt(x**2 + y**2) + * return rho # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_rho); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "total_least_squares.pyx":54 - * cdef get_rho(float x, float y): - * rho = math.sqrt(x**2 + y**2) - * return rho # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_rho); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 54, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "total_least_squares.pyx":52 - * +/* "total_least_squares.pyx":52 + * * # Rho * cdef get_rho(float x, float y): # <<<<<<<<<<<<<< * rho = math.sqrt(x**2 + y**2) * return rho */ - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("total_least_squares.get_rho", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; +/* function exit code */ +__pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("total_least_squares.get_rho", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; +__pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } /* "total_least_squares.pyx":58 - * + * * # Rho Vector * cdef get_rho_vector(points, int num_points): # <<<<<<<<<<<<<< * rho_mat = [] @@ -2898,789 +3000,937 @@ static PyObject *__pyx_f_19total_least_squares_get_rho(float __pyx_v_x, float __ */ static PyObject *__pyx_f_19total_least_squares_get_rho_vector(PyObject *__pyx_v_points, int __pyx_v_num_points) { - PyObject *__pyx_v_rho_mat = NULL; - int __pyx_v_i; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - float __pyx_t_6; - float __pyx_t_7; - int __pyx_t_8; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_rho_vector", 1); - - /* "total_least_squares.pyx":59 - * # Rho Vector - * cdef get_rho_vector(points, int num_points): - * rho_mat = [] # <<<<<<<<<<<<<< - * cdef int i - * - */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 59, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_rho_mat = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "total_least_squares.pyx":62 - * cdef int i - * - * for i in range(num_points): # <<<<<<<<<<<<<< - * rho_mat.append(get_rho(points[i][0], points[i][1])) - * - */ - __pyx_t_2 = __pyx_v_num_points; - __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; - - /* "total_least_squares.pyx":63 - * - * for i in range(num_points): - * rho_mat.append(get_rho(points[i][0], points[i][1])) # <<<<<<<<<<<<<< - * - * return rho_mat - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 63, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 63, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error) + PyObject *__pyx_v_rho_mat = NULL; + int __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + float __pyx_t_6; + float __pyx_t_7; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_rho_vector", 1); + + /* "total_least_squares.pyx":59 + * # Rho Vector + * cdef get_rho_vector(points, int num_points): + * rho_mat = [] # <<<<<<<<<<<<<< + * cdef int i + * + */ + __pyx_t_1 = PyList_New(0); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 59, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_7 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_7 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __pyx_f_19total_least_squares_get_rho(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_rho_mat, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 63, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } - - /* "total_least_squares.pyx":65 - * rho_mat.append(get_rho(points[i][0], points[i][1])) - * - * return rho_mat # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_rho_mat); - __pyx_r = __pyx_v_rho_mat; - goto __pyx_L0; + __pyx_v_rho_mat = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "total_least_squares.pyx":62 + * cdef int i + * + * for i in range(num_points): # <<<<<<<<<<<<<< + * rho_mat.append(get_rho(points[i][0], points[i][1])) + * + */ + __pyx_t_2 = __pyx_v_num_points; + __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; + + /* "total_least_squares.pyx":63 + * + * for i in range(num_points): + * rho_mat.append(get_rho(points[i][0], points[i][1])) # <<<<<<<<<<<<<< + * + * return rho_mat + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); + if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_7 = __pyx_PyFloat_AsFloat(__pyx_t_1); + if (unlikely((__pyx_t_7 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __pyx_f_19total_least_squares_get_rho(__pyx_t_6, __pyx_t_7); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_rho_mat, __pyx_t_1); + if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); + __pyx_t_1 = 0; + } + + /* "total_least_squares.pyx":65 + * rho_mat.append(get_rho(points[i][0], points[i][1])) + * + * return rho_mat # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_rho_mat); + __pyx_r = __pyx_v_rho_mat; + goto __pyx_L0; - /* "total_least_squares.pyx":58 - * +/* "total_least_squares.pyx":58 + * * # Rho Vector * cdef get_rho_vector(points, int num_points): # <<<<<<<<<<<<<< * rho_mat = [] * cdef int i */ - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("total_least_squares.get_rho_vector", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_rho_mat); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; +/* function exit code */ +__pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("total_least_squares.get_rho_vector", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; +__pyx_L0:; + __Pyx_XDECREF(__pyx_v_rho_mat); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } /* "total_least_squares.pyx":69 - * + * * # Weights, W * cdef get_weights(points, int num_points, float x_mean, float y_mean): # <<<<<<<<<<<<<< * w_mat = [] * cdef int i */ -static PyObject *__pyx_f_19total_least_squares_get_weights(PyObject *__pyx_v_points, int __pyx_v_num_points, float __pyx_v_x_mean, float __pyx_v_y_mean) { - PyObject *__pyx_v_w_mat = NULL; - int __pyx_v_i; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; - int __pyx_t_7; - float __pyx_t_8; - int __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_weights", 1); - - /* "total_least_squares.pyx":70 - * # Weights, W - * cdef get_weights(points, int num_points, float x_mean, float y_mean): - * w_mat = [] # <<<<<<<<<<<<<< - * cdef int i - * - */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 70, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_w_mat = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "total_least_squares.pyx":73 - * cdef int i - * - * for i in range(num_points): # <<<<<<<<<<<<<< - * w_mat.append(get_point_var(points[i][0], points[i][1], x_mean, y_mean)) - * - */ - __pyx_t_2 = __pyx_v_num_points; - __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; - - /* "total_least_squares.pyx":74 - * - * for i in range(num_points): - * w_mat.append(get_point_var(points[i][0], points[i][1], x_mean, y_mean)) # <<<<<<<<<<<<<< - * - * return w_mat - */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error) +static PyObject *__pyx_f_19total_least_squares_get_weights(PyObject *__pyx_v_points, int __pyx_v_num_points, + float __pyx_v_x_mean, float __pyx_v_y_mean) { + PyObject *__pyx_v_w_mat = NULL; + int __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_t_7; + float __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_weights", 1); + + /* "total_least_squares.pyx":70 + * # Weights, W + * cdef get_weights(points, int num_points, float x_mean, float y_mean): + * w_mat = [] # <<<<<<<<<<<<<< + * cdef int i + * + */ + __pyx_t_1 = PyList_New(0); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_8 = __pyx_f_19total_least_squares_get_point_var(__pyx_t_6, __pyx_t_7, __pyx_v_x_mean, __pyx_v_y_mean); if (unlikely(__pyx_t_8 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 74, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble(__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_w_mat, __pyx_t_1); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } - - /* "total_least_squares.pyx":76 - * w_mat.append(get_point_var(points[i][0], points[i][1], x_mean, y_mean)) - * - * return w_mat # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_w_mat); - __pyx_r = __pyx_v_w_mat; - goto __pyx_L0; + __pyx_v_w_mat = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "total_least_squares.pyx":73 + * cdef int i + * + * for i in range(num_points): # <<<<<<<<<<<<<< + * w_mat.append(get_point_var(points[i][0], points[i][1], x_mean, y_mean)) + * + */ + __pyx_t_2 = __pyx_v_num_points; + __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; + + /* "total_least_squares.pyx":74 + * + * for i in range(num_points): + * w_mat.append(get_point_var(points[i][0], points[i][1], x_mean, y_mean)) # <<<<<<<<<<<<<< + * + * return w_mat + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_5); + if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_1); + if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_8 = __pyx_f_19total_least_squares_get_point_var(__pyx_t_6, __pyx_t_7, __pyx_v_x_mean, __pyx_v_y_mean); + if (unlikely(__pyx_t_8 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 74, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_t_8); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_w_mat, __pyx_t_1); + if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); + __pyx_t_1 = 0; + } + + /* "total_least_squares.pyx":76 + * w_mat.append(get_point_var(points[i][0], points[i][1], x_mean, y_mean)) + * + * return w_mat # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_w_mat); + __pyx_r = __pyx_v_w_mat; + goto __pyx_L0; - /* "total_least_squares.pyx":69 - * +/* "total_least_squares.pyx":69 + * * # Weights, W * cdef get_weights(points, int num_points, float x_mean, float y_mean): # <<<<<<<<<<<<<< * w_mat = [] * cdef int i */ - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("total_least_squares.get_weights", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_w_mat); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; +/* function exit code */ +__pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("total_least_squares.get_weights", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; +__pyx_L0:; + __Pyx_XDECREF(__pyx_v_w_mat); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } /* "total_least_squares.pyx":80 - * + * * # x_w * cdef float get_x_weight(w_mat, rho_mat, theta_mat, w_sum, int num_points): # <<<<<<<<<<<<<< * cdef float x_weight = 0 * cdef int i */ -static float __pyx_f_19total_least_squares_get_x_weight(PyObject *__pyx_v_w_mat, PyObject *__pyx_v_rho_mat, PyObject *__pyx_v_theta_mat, PyObject *__pyx_v_w_sum, int __pyx_v_num_points) { - float __pyx_v_x_weight; - int __pyx_v_i; - float __pyx_r; - __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; - double __pyx_t_8; - float __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_x_weight", 1); - - /* "total_least_squares.pyx":81 - * # x_w - * cdef float get_x_weight(w_mat, rho_mat, theta_mat, w_sum, int num_points): - * cdef float x_weight = 0 # <<<<<<<<<<<<<< - * cdef int i - * - */ - __pyx_v_x_weight = 0.0; - - /* "total_least_squares.pyx":84 - * cdef int i - * - * for i in range(num_points): # <<<<<<<<<<<<<< - * x_weight += w_mat[i] * rho_mat[i] * math.cos(theta_mat[i]) - * - */ - __pyx_t_1 = __pyx_v_num_points; - __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; - - /* "total_least_squares.pyx":85 - * - * for i in range(num_points): - * x_weight += w_mat[i] * rho_mat[i] * math.cos(theta_mat[i]) # <<<<<<<<<<<<<< - * - * x_weight = (1/w_sum) * x_weight - */ - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_x_weight); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_w_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_rho_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyNumber_Multiply(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 85, __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_t_6 = __Pyx_GetItemInt(__pyx_v_theta_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_8 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyFloat_FromDouble(cos(__pyx_t_8)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 85, __pyx_L1_error) +static float __pyx_f_19total_least_squares_get_x_weight(PyObject *__pyx_v_w_mat, PyObject *__pyx_v_rho_mat, + PyObject *__pyx_v_theta_mat, PyObject *__pyx_v_w_sum, + int __pyx_v_num_points) { + float __pyx_v_x_weight; + int __pyx_v_i; + float __pyx_r; + __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; + double __pyx_t_8; + float __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_x_weight", 1); + + /* "total_least_squares.pyx":81 + * # x_w + * cdef float get_x_weight(w_mat, rho_mat, theta_mat, w_sum, int num_points): + * cdef float x_weight = 0 # <<<<<<<<<<<<<< + * cdef int i + * + */ + __pyx_v_x_weight = 0.0; + + /* "total_least_squares.pyx":84 + * cdef int i + * + * for i in range(num_points): # <<<<<<<<<<<<<< + * x_weight += w_mat[i] * rho_mat[i] * math.cos(theta_mat[i]) + * + */ + __pyx_t_1 = __pyx_v_num_points; + __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; + + /* "total_least_squares.pyx":85 + * + * for i in range(num_points): + * x_weight += w_mat[i] * rho_mat[i] * math.cos(theta_mat[i]) # <<<<<<<<<<<<<< + * + * x_weight = (1/w_sum) * x_weight + */ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_x_weight); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_w_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_rho_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyNumber_Multiply(__pyx_t_5, __pyx_t_6); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 85, __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_t_6 = __Pyx_GetItemInt(__pyx_v_theta_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_t_6); + if (unlikely((__pyx_t_8 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = PyFloat_FromDouble(cos(__pyx_t_8)); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = PyNumber_Multiply(__pyx_t_7, __pyx_t_6); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_5); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 85, __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_9 = __pyx_PyFloat_AsFloat(__pyx_t_6); + if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __pyx_v_x_weight = __pyx_t_9; + } + + /* "total_least_squares.pyx":87 + * x_weight += w_mat[i] * rho_mat[i] * math.cos(theta_mat[i]) + * + * x_weight = (1/w_sum) * x_weight # <<<<<<<<<<<<<< + * return x_weight + * + */ + __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_int_1, __pyx_v_w_sum); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyNumber_Multiply(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 85, __pyx_L1_error) + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_x_weight); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 85, __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_9 = __pyx_PyFloat_AsFloat(__pyx_t_6); if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = PyNumber_Multiply(__pyx_t_6, __pyx_t_5); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_4); + if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = 0; __pyx_v_x_weight = __pyx_t_9; - } - - /* "total_least_squares.pyx":87 - * x_weight += w_mat[i] * rho_mat[i] * math.cos(theta_mat[i]) - * - * x_weight = (1/w_sum) * x_weight # <<<<<<<<<<<<<< - * return x_weight - * - */ - __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_int_1, __pyx_v_w_sum); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_x_weight); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = PyNumber_Multiply(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_4); if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_x_weight = __pyx_t_9; - - /* "total_least_squares.pyx":88 - * - * x_weight = (1/w_sum) * x_weight - * return x_weight # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_x_weight; - goto __pyx_L0; - /* "total_least_squares.pyx":80 - * + /* "total_least_squares.pyx":88 + * + * x_weight = (1/w_sum) * x_weight + * return x_weight # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_x_weight; + goto __pyx_L0; + +/* "total_least_squares.pyx":80 + * * # x_w * cdef float get_x_weight(w_mat, rho_mat, theta_mat, w_sum, int num_points): # <<<<<<<<<<<<<< * cdef float x_weight = 0 * cdef int i */ - /* 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("total_least_squares.get_x_weight", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; +/* 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("total_least_squares.get_x_weight", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; +__pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; } /* "total_least_squares.pyx":92 - * + * * # y_w * cdef float get_y_weight(w_mat, rho_mat, theta_mat, w_sum, int num_points): # <<<<<<<<<<<<<< * cdef float y_weight = 0 * cdef int i */ -static float __pyx_f_19total_least_squares_get_y_weight(PyObject *__pyx_v_w_mat, PyObject *__pyx_v_rho_mat, PyObject *__pyx_v_theta_mat, PyObject *__pyx_v_w_sum, int __pyx_v_num_points) { - float __pyx_v_y_weight; - int __pyx_v_i; - float __pyx_r; - __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; - double __pyx_t_8; - float __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_y_weight", 1); - - /* "total_least_squares.pyx":93 - * # y_w - * cdef float get_y_weight(w_mat, rho_mat, theta_mat, w_sum, int num_points): - * cdef float y_weight = 0 # <<<<<<<<<<<<<< - * cdef int i - * - */ - __pyx_v_y_weight = 0.0; - - /* "total_least_squares.pyx":96 - * cdef int i - * - * for i in range(num_points): # <<<<<<<<<<<<<< - * y_weight += w_mat[i] * rho_mat[i] * math.sin(theta_mat[i]) - * - */ - __pyx_t_1 = __pyx_v_num_points; - __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; - - /* "total_least_squares.pyx":97 - * - * for i in range(num_points): - * y_weight += w_mat[i] * rho_mat[i] * math.sin(theta_mat[i]) # <<<<<<<<<<<<<< - * - * y_weight = (1/w_sum) * y_weight - */ - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_y_weight); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_w_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_rho_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyNumber_Multiply(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 97, __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_t_6 = __Pyx_GetItemInt(__pyx_v_theta_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_8 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyFloat_FromDouble(sin(__pyx_t_8)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 97, __pyx_L1_error) +static float __pyx_f_19total_least_squares_get_y_weight(PyObject *__pyx_v_w_mat, PyObject *__pyx_v_rho_mat, + PyObject *__pyx_v_theta_mat, PyObject *__pyx_v_w_sum, + int __pyx_v_num_points) { + float __pyx_v_y_weight; + int __pyx_v_i; + float __pyx_r; + __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; + double __pyx_t_8; + float __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_y_weight", 1); + + /* "total_least_squares.pyx":93 + * # y_w + * cdef float get_y_weight(w_mat, rho_mat, theta_mat, w_sum, int num_points): + * cdef float y_weight = 0 # <<<<<<<<<<<<<< + * cdef int i + * + */ + __pyx_v_y_weight = 0.0; + + /* "total_least_squares.pyx":96 + * cdef int i + * + * for i in range(num_points): # <<<<<<<<<<<<<< + * y_weight += w_mat[i] * rho_mat[i] * math.sin(theta_mat[i]) + * + */ + __pyx_t_1 = __pyx_v_num_points; + __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; + + /* "total_least_squares.pyx":97 + * + * for i in range(num_points): + * y_weight += w_mat[i] * rho_mat[i] * math.sin(theta_mat[i]) # <<<<<<<<<<<<<< + * + * y_weight = (1/w_sum) * y_weight + */ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_y_weight); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_w_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_rho_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyNumber_Multiply(__pyx_t_5, __pyx_t_6); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 97, __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_t_6 = __Pyx_GetItemInt(__pyx_v_theta_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_t_6); + if (unlikely((__pyx_t_8 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = PyFloat_FromDouble(sin(__pyx_t_8)); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = PyNumber_Multiply(__pyx_t_7, __pyx_t_6); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_5); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 97, __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_9 = __pyx_PyFloat_AsFloat(__pyx_t_6); + if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __pyx_v_y_weight = __pyx_t_9; + } + + /* "total_least_squares.pyx":99 + * y_weight += w_mat[i] * rho_mat[i] * math.sin(theta_mat[i]) + * + * y_weight = (1/w_sum) * y_weight # <<<<<<<<<<<<<< + * return y_weight + * + */ + __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_int_1, __pyx_v_w_sum); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyNumber_Multiply(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error) + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_y_weight); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 97, __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_9 = __pyx_PyFloat_AsFloat(__pyx_t_6); if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = PyNumber_Multiply(__pyx_t_6, __pyx_t_5); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_4); + if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = 0; __pyx_v_y_weight = __pyx_t_9; - } - - /* "total_least_squares.pyx":99 - * y_weight += w_mat[i] * rho_mat[i] * math.sin(theta_mat[i]) - * - * y_weight = (1/w_sum) * y_weight # <<<<<<<<<<<<<< - * return y_weight - * - */ - __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_int_1, __pyx_v_w_sum); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 99, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_y_weight); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = PyNumber_Multiply(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 99, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_4); if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 99, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_y_weight = __pyx_t_9; - - /* "total_least_squares.pyx":100 - * - * y_weight = (1/w_sum) * y_weight - * return y_weight # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_y_weight; - goto __pyx_L0; - /* "total_least_squares.pyx":92 - * + /* "total_least_squares.pyx":100 + * + * y_weight = (1/w_sum) * y_weight + * return y_weight # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_y_weight; + goto __pyx_L0; + +/* "total_least_squares.pyx":92 + * * # y_w * cdef float get_y_weight(w_mat, rho_mat, theta_mat, w_sum, int num_points): # <<<<<<<<<<<<<< * cdef float y_weight = 0 * cdef int i */ - /* 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("total_least_squares.get_y_weight", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; +/* 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("total_least_squares.get_y_weight", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; +__pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; } /* "total_least_squares.pyx":104 - * + * * # alpha, rearrange (4) to get alpha * cdef float get_alpha(points, int num_points, w_mat, float x_weight, float y_weight): # <<<<<<<<<<<<<< * cdef float numerator = 0 * cdef float denominator = 0 */ -static float __pyx_f_19total_least_squares_get_alpha(PyObject *__pyx_v_points, int __pyx_v_num_points, PyObject *__pyx_v_w_mat, float __pyx_v_x_weight, float __pyx_v_y_weight) { - float __pyx_v_numerator; - float __pyx_v_denominator; - int __pyx_v_i; - float __pyx_v_tan_2_alpha; - float __pyx_v_y_delta; - float __pyx_v_alpha; - float __pyx_r; - __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; - float __pyx_t_9; - PyObject *__pyx_t_10 = NULL; - long __pyx_t_11; - int __pyx_t_12; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_alpha", 1); - - /* "total_least_squares.pyx":105 - * # alpha, rearrange (4) to get alpha - * cdef float get_alpha(points, int num_points, w_mat, float x_weight, float y_weight): - * cdef float numerator = 0 # <<<<<<<<<<<<<< - * cdef float denominator = 0 - * cdef int i - */ - __pyx_v_numerator = 0.0; - - /* "total_least_squares.pyx":106 - * cdef float get_alpha(points, int num_points, w_mat, float x_weight, float y_weight): - * cdef float numerator = 0 - * cdef float denominator = 0 # <<<<<<<<<<<<<< - * cdef int i - * - */ - __pyx_v_denominator = 0.0; - - /* "total_least_squares.pyx":109 - * cdef int i - * - * for i in range(num_points): # <<<<<<<<<<<<<< - * numerator += w_mat[i] * (y_weight - points[i][1]) * (x_weight - points[i][0]) - * denominator += w_mat[i] * ((y_weight - points[i][1])**2 - (x_weight - points[i][0])**2) - */ - __pyx_t_1 = __pyx_v_num_points; - __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; - - /* "total_least_squares.pyx":110 - * - * for i in range(num_points): - * numerator += w_mat[i] * (y_weight - points[i][1]) * (x_weight - points[i][0]) # <<<<<<<<<<<<<< - * denominator += w_mat[i] * ((y_weight - points[i][1])**2 - (x_weight - points[i][0])**2) - * - */ - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_numerator); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_w_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyFloat_FromDouble(__pyx_v_y_weight); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyNumber_Subtract(__pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyNumber_Multiply(__pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_x_weight); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyNumber_Subtract(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyNumber_Multiply(__pyx_t_8, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_numerator = __pyx_t_9; - - /* "total_least_squares.pyx":111 - * for i in range(num_points): - * numerator += w_mat[i] * (y_weight - points[i][1]) * (x_weight - points[i][0]) - * denominator += w_mat[i] * ((y_weight - points[i][1])**2 - (x_weight - points[i][0])**2) # <<<<<<<<<<<<<< - * - * numerator = -2 * numerator - */ - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_denominator); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_w_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_y_weight); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_8, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyNumber_Subtract(__pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyNumber_Power(__pyx_t_8, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyFloat_FromDouble(__pyx_v_x_weight); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyNumber_Subtract(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) +static float __pyx_f_19total_least_squares_get_alpha(PyObject *__pyx_v_points, int __pyx_v_num_points, + PyObject *__pyx_v_w_mat, float __pyx_v_x_weight, + float __pyx_v_y_weight) { + float __pyx_v_numerator; + float __pyx_v_denominator; + int __pyx_v_i; + float __pyx_v_tan_2_alpha; + float __pyx_v_y_delta; + float __pyx_v_alpha; + float __pyx_r; + __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; + float __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + long __pyx_t_11; + int __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_alpha", 1); + + /* "total_least_squares.pyx":105 + * # alpha, rearrange (4) to get alpha + * cdef float get_alpha(points, int num_points, w_mat, float x_weight, float y_weight): + * cdef float numerator = 0 # <<<<<<<<<<<<<< + * cdef float denominator = 0 + * cdef int i + */ + __pyx_v_numerator = 0.0; + + /* "total_least_squares.pyx":106 + * cdef float get_alpha(points, int num_points, w_mat, float x_weight, float y_weight): + * cdef float numerator = 0 + * cdef float denominator = 0 # <<<<<<<<<<<<<< + * cdef int i + * + */ + __pyx_v_denominator = 0.0; + + /* "total_least_squares.pyx":109 + * cdef int i + * + * for i in range(num_points): # <<<<<<<<<<<<<< + * numerator += w_mat[i] * (y_weight - points[i][1]) * (x_weight - points[i][0]) + * denominator += w_mat[i] * ((y_weight - points[i][1])**2 - (x_weight - points[i][0])**2) + */ + __pyx_t_1 = __pyx_v_num_points; + __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; + + /* "total_least_squares.pyx":110 + * + * for i in range(num_points): + * numerator += w_mat[i] * (y_weight - points[i][1]) * (x_weight - points[i][0]) # + * <<<<<<<<<<<<<< denominator += w_mat[i] * ((y_weight - points[i][1])**2 - (x_weight - points[i][0])**2) + * + */ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_numerator); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_w_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_y_weight); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = PyNumber_Subtract(__pyx_t_6, __pyx_t_8); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Multiply(__pyx_t_5, __pyx_t_7); + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_x_weight); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Subtract(__pyx_t_7, __pyx_t_6); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = PyNumber_Multiply(__pyx_t_8, __pyx_t_5); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); + __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_6); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_5); + if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_v_numerator = __pyx_t_9; + + /* "total_least_squares.pyx":111 + * for i in range(num_points): + * numerator += w_mat[i] * (y_weight - points[i][1]) * (x_weight - points[i][0]) + * denominator += w_mat[i] * ((y_weight - points[i][1])**2 - (x_weight - points[i][0])**2) # + * <<<<<<<<<<<<<< + * + * numerator = -2 * numerator + */ + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_denominator); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_w_mat, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_y_weight); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_8, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Subtract(__pyx_t_4, __pyx_t_7); + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = PyNumber_Power(__pyx_t_8, __pyx_int_2, Py_None); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = PyFloat_FromDouble(__pyx_v_x_weight); + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Subtract(__pyx_t_8, __pyx_t_10); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); + __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_10); + __pyx_t_10 = 0; + __pyx_t_10 = PyNumber_Power(__pyx_t_4, __pyx_int_2, Py_None); + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Subtract(__pyx_t_7, __pyx_t_10); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_10); + __pyx_t_10 = 0; + __pyx_t_10 = PyNumber_Multiply(__pyx_t_6, __pyx_t_4); + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_t_5, __pyx_t_10); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_10); + __pyx_t_10 = 0; + __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_4); + if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = 0; + __pyx_v_denominator = __pyx_t_9; + } + + /* "total_least_squares.pyx":113 + * denominator += w_mat[i] * ((y_weight - points[i][1])**2 - (x_weight - points[i][0])**2) + * + * numerator = -2 * numerator # <<<<<<<<<<<<<< + * cdef float tan_2_alpha = numerator / denominator + * + */ + __pyx_v_numerator = (-2.0 * __pyx_v_numerator); + + /* "total_least_squares.pyx":114 + * + * numerator = -2 * numerator + * cdef float tan_2_alpha = numerator / denominator # <<<<<<<<<<<<<< + * + * # - Custom Code - + */ + if (unlikely(__pyx_v_denominator == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(0, 114, __pyx_L1_error) + } + __pyx_v_tan_2_alpha = (__pyx_v_numerator / __pyx_v_denominator); + + /* "total_least_squares.pyx":119 + * # If the difference in height between first and last point is negative, + * # then make tan_2_alpha negative. Otherwise, positive. + * cdef float y_delta = points[0][1] - points[num_points - 1][1] # <<<<<<<<<<<<<< + * if y_delta >= 0: + * tan_2_alpha = -abs(tan_2_alpha) + */ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_points, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = PyNumber_Power(__pyx_t_4, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 111, __pyx_L1_error) + __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyNumber_Subtract(__pyx_t_7, __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_11 = (__pyx_v_num_points - 1); + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_points, __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = PyNumber_Multiply(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_t_5, __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Subtract(__pyx_t_10, __pyx_t_5); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_4); if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_denominator = __pyx_t_9; - } - - /* "total_least_squares.pyx":113 - * denominator += w_mat[i] * ((y_weight - points[i][1])**2 - (x_weight - points[i][0])**2) - * - * numerator = -2 * numerator # <<<<<<<<<<<<<< - * cdef float tan_2_alpha = numerator / denominator - * - */ - __pyx_v_numerator = (-2.0 * __pyx_v_numerator); - - /* "total_least_squares.pyx":114 - * - * numerator = -2 * numerator - * cdef float tan_2_alpha = numerator / denominator # <<<<<<<<<<<<<< - * - * # - Custom Code - - */ - if (unlikely(__pyx_v_denominator == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "float division"); - __PYX_ERR(0, 114, __pyx_L1_error) - } - __pyx_v_tan_2_alpha = (__pyx_v_numerator / __pyx_v_denominator); - - /* "total_least_squares.pyx":119 - * # If the difference in height between first and last point is negative, - * # then make tan_2_alpha negative. Otherwise, positive. - * cdef float y_delta = points[0][1] - points[num_points - 1][1] # <<<<<<<<<<<<<< - * if y_delta >= 0: - * tan_2_alpha = -abs(tan_2_alpha) - */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_points, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 119, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 119, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_11 = (__pyx_v_num_points - 1); - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_points, __pyx_t_11, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 119, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 119, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyNumber_Subtract(__pyx_t_10, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 119, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_4); if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_y_delta = __pyx_t_9; - - /* "total_least_squares.pyx":120 - * # then make tan_2_alpha negative. Otherwise, positive. - * cdef float y_delta = points[0][1] - points[num_points - 1][1] - * if y_delta >= 0: # <<<<<<<<<<<<<< - * tan_2_alpha = -abs(tan_2_alpha) - * else: - */ - __pyx_t_12 = (__pyx_v_y_delta >= 0.0); - if (__pyx_t_12) { - - /* "total_least_squares.pyx":121 - * cdef float y_delta = points[0][1] - points[num_points - 1][1] - * if y_delta >= 0: - * tan_2_alpha = -abs(tan_2_alpha) # <<<<<<<<<<<<<< - * else: - * tan_2_alpha = abs(tan_2_alpha) - */ - __pyx_v_tan_2_alpha = (-fabsf(__pyx_v_tan_2_alpha)); + __Pyx_DECREF(__pyx_t_10); + __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_4); + if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = 0; + __pyx_v_y_delta = __pyx_t_9; /* "total_least_squares.pyx":120 - * # then make tan_2_alpha negative. Otherwise, positive. - * cdef float y_delta = points[0][1] - points[num_points - 1][1] - * if y_delta >= 0: # <<<<<<<<<<<<<< - * tan_2_alpha = -abs(tan_2_alpha) - * else: - */ - goto __pyx_L5; - } - - /* "total_least_squares.pyx":123 - * tan_2_alpha = -abs(tan_2_alpha) - * else: - * tan_2_alpha = abs(tan_2_alpha) # <<<<<<<<<<<<<< - * - * cdef float alpha = math.atan(tan_2_alpha) / 2 - */ - /*else*/ { - __pyx_v_tan_2_alpha = fabsf(__pyx_v_tan_2_alpha); - } - __pyx_L5:; - - /* "total_least_squares.pyx":125 - * tan_2_alpha = abs(tan_2_alpha) - * - * cdef float alpha = math.atan(tan_2_alpha) / 2 # <<<<<<<<<<<<<< - * return alpha - * - */ - __pyx_v_alpha = (atan(__pyx_v_tan_2_alpha) / 2.0); - - /* "total_least_squares.pyx":126 - * - * cdef float alpha = math.atan(tan_2_alpha) / 2 - * return alpha # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_alpha; - goto __pyx_L0; + * # then make tan_2_alpha negative. Otherwise, positive. + * cdef float y_delta = points[0][1] - points[num_points - 1][1] + * if y_delta >= 0: # <<<<<<<<<<<<<< + * tan_2_alpha = -abs(tan_2_alpha) + * else: + */ + __pyx_t_12 = (__pyx_v_y_delta >= 0.0); + if (__pyx_t_12) { + /* "total_least_squares.pyx":121 + * cdef float y_delta = points[0][1] - points[num_points - 1][1] + * if y_delta >= 0: + * tan_2_alpha = -abs(tan_2_alpha) # <<<<<<<<<<<<<< + * else: + * tan_2_alpha = abs(tan_2_alpha) + */ + __pyx_v_tan_2_alpha = (-fabsf(__pyx_v_tan_2_alpha)); + + /* "total_least_squares.pyx":120 + * # then make tan_2_alpha negative. Otherwise, positive. + * cdef float y_delta = points[0][1] - points[num_points - 1][1] + * if y_delta >= 0: # <<<<<<<<<<<<<< + * tan_2_alpha = -abs(tan_2_alpha) + * else: + */ + goto __pyx_L5; + } + + /* "total_least_squares.pyx":123 + * tan_2_alpha = -abs(tan_2_alpha) + * else: + * tan_2_alpha = abs(tan_2_alpha) # <<<<<<<<<<<<<< + * + * cdef float alpha = math.atan(tan_2_alpha) / 2 + */ + /*else*/ { __pyx_v_tan_2_alpha = fabsf(__pyx_v_tan_2_alpha); } +__pyx_L5:; + + /* "total_least_squares.pyx":125 + * tan_2_alpha = abs(tan_2_alpha) + * + * cdef float alpha = math.atan(tan_2_alpha) / 2 # <<<<<<<<<<<<<< + * return alpha + * + */ + __pyx_v_alpha = (atan(__pyx_v_tan_2_alpha) / 2.0); + + /* "total_least_squares.pyx":126 + * + * cdef float alpha = math.atan(tan_2_alpha) / 2 + * return alpha # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_alpha; + goto __pyx_L0; - /* "total_least_squares.pyx":104 - * +/* "total_least_squares.pyx":104 + * * # alpha, rearrange (4) to get alpha * cdef float get_alpha(points, int num_points, w_mat, float x_weight, float y_weight): # <<<<<<<<<<<<<< * cdef float numerator = 0 * cdef float denominator = 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_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_10); - __Pyx_AddTraceback("total_least_squares.get_alpha", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; +/* function exit code */ +__pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("total_least_squares.get_alpha", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; +__pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; } /* "total_least_squares.pyx":130 - * + * * # r * cdef float get_r(float x_weight, float y_weight, float alpha): # <<<<<<<<<<<<<< * cdef float r = x_weight * math.cos(alpha) + y_weight * math.sin(alpha) @@ -3688,43 +3938,43 @@ static float __pyx_f_19total_least_squares_get_alpha(PyObject *__pyx_v_points, i */ static float __pyx_f_19total_least_squares_get_r(float __pyx_v_x_weight, float __pyx_v_y_weight, float __pyx_v_alpha) { - float __pyx_v_r; - float __pyx_r; - - /* "total_least_squares.pyx":131 - * # r - * cdef float get_r(float x_weight, float y_weight, float alpha): - * cdef float r = x_weight * math.cos(alpha) + y_weight * math.sin(alpha) # <<<<<<<<<<<<<< - * return r - * - */ - __pyx_v_r = ((__pyx_v_x_weight * cos(__pyx_v_alpha)) + (__pyx_v_y_weight * sin(__pyx_v_alpha))); - - /* "total_least_squares.pyx":132 - * cdef float get_r(float x_weight, float y_weight, float alpha): - * cdef float r = x_weight * math.cos(alpha) + y_weight * math.sin(alpha) - * return r # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_r; - goto __pyx_L0; + float __pyx_v_r; + float __pyx_r; + + /* "total_least_squares.pyx":131 + * # r + * cdef float get_r(float x_weight, float y_weight, float alpha): + * cdef float r = x_weight * math.cos(alpha) + y_weight * math.sin(alpha) # <<<<<<<<<<<<<< + * return r + * + */ + __pyx_v_r = ((__pyx_v_x_weight * cos(__pyx_v_alpha)) + (__pyx_v_y_weight * sin(__pyx_v_alpha))); + + /* "total_least_squares.pyx":132 + * cdef float get_r(float x_weight, float y_weight, float alpha): + * cdef float r = x_weight * math.cos(alpha) + y_weight * math.sin(alpha) + * return r # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_r; + goto __pyx_L0; - /* "total_least_squares.pyx":130 - * +/* "total_least_squares.pyx":130 + * * # r * cdef float get_r(float x_weight, float y_weight, float alpha): # <<<<<<<<<<<<<< * cdef float r = x_weight * math.cos(alpha) + y_weight * math.sin(alpha) * return r */ - /* function exit code */ - __pyx_L0:; - return __pyx_r; +/* function exit code */ +__pyx_L0:; + return __pyx_r; } /* "total_least_squares.pyx":136 - * + * * # Gradient, m * cdef float get_m(float alpha, float y_weight): # <<<<<<<<<<<<<< * cdef float m = math.tan(alpha) @@ -3732,930 +3982,1037 @@ static float __pyx_f_19total_least_squares_get_r(float __pyx_v_x_weight, float _ */ static float __pyx_f_19total_least_squares_get_m(float __pyx_v_alpha, CYTHON_UNUSED float __pyx_v_y_weight) { - float __pyx_v_m; - float __pyx_r; - - /* "total_least_squares.pyx":137 - * # Gradient, m - * cdef float get_m(float alpha, float y_weight): - * cdef float m = math.tan(alpha) # <<<<<<<<<<<<<< - * return m - * - */ - __pyx_v_m = tan(__pyx_v_alpha); - - /* "total_least_squares.pyx":138 - * cdef float get_m(float alpha, float y_weight): - * cdef float m = math.tan(alpha) - * return m # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_m; - goto __pyx_L0; + float __pyx_v_m; + float __pyx_r; + + /* "total_least_squares.pyx":137 + * # Gradient, m + * cdef float get_m(float alpha, float y_weight): + * cdef float m = math.tan(alpha) # <<<<<<<<<<<<<< + * return m + * + */ + __pyx_v_m = tan(__pyx_v_alpha); + + /* "total_least_squares.pyx":138 + * cdef float get_m(float alpha, float y_weight): + * cdef float m = math.tan(alpha) + * return m # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_m; + goto __pyx_L0; - /* "total_least_squares.pyx":136 - * +/* "total_least_squares.pyx":136 + * * # Gradient, m * cdef float get_m(float alpha, float y_weight): # <<<<<<<<<<<<<< * cdef float m = math.tan(alpha) * return m */ - /* function exit code */ - __pyx_L0:; - return __pyx_r; +/* function exit code */ +__pyx_L0:; + return __pyx_r; } /* "total_least_squares.pyx":142 - * + * * # Intercept, b * cdef get_b(points, int num_points, float r, float alpha, float m): # <<<<<<<<<<<<<< * cdef float b = 0 * cdef int i */ -static PyObject *__pyx_f_19total_least_squares_get_b(PyObject *__pyx_v_points, int __pyx_v_num_points, CYTHON_UNUSED float __pyx_v_r, CYTHON_UNUSED float __pyx_v_alpha, float __pyx_v_m) { - float __pyx_v_b; - int __pyx_v_i; - 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; - float __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_b", 1); - - /* "total_least_squares.pyx":143 - * # Intercept, b - * cdef get_b(points, int num_points, float r, float alpha, float m): - * cdef float b = 0 # <<<<<<<<<<<<<< - * cdef int i - * - */ - __pyx_v_b = 0.0; - - /* "total_least_squares.pyx":146 - * cdef int i - * - * for i in range(num_points): # <<<<<<<<<<<<<< - * b += points[i][1] - m * points[i][0] - * - */ - __pyx_t_1 = __pyx_v_num_points; - __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; - - /* "total_least_squares.pyx":147 - * - * for i in range(num_points): - * b += points[i][1] - m * points[i][0] # <<<<<<<<<<<<<< - * - * b = b / num_points - */ - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_b); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_m); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyNumber_Multiply(__pyx_t_5, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyNumber_Subtract(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 147, __pyx_L1_error) +static PyObject *__pyx_f_19total_least_squares_get_b(PyObject *__pyx_v_points, int __pyx_v_num_points, + CYTHON_UNUSED float __pyx_v_r, CYTHON_UNUSED float __pyx_v_alpha, + float __pyx_v_m) { + float __pyx_v_b; + int __pyx_v_i; + 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; + float __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_b", 1); + + /* "total_least_squares.pyx":143 + * # Intercept, b + * cdef get_b(points, int num_points, float r, float alpha, float m): + * cdef float b = 0 # <<<<<<<<<<<<<< + * cdef int i + * + */ + __pyx_v_b = 0.0; + + /* "total_least_squares.pyx":146 + * cdef int i + * + * for i in range(num_points): # <<<<<<<<<<<<<< + * b += points[i][1] - m * points[i][0] + * + */ + __pyx_t_1 = __pyx_v_num_points; + __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; + + /* "total_least_squares.pyx":147 + * + * for i in range(num_points): + * b += points[i][1] - m * points[i][0] # <<<<<<<<<<<<<< + * + * b = b / num_points + */ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_b); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_m); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_points, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = PyNumber_Multiply(__pyx_t_5, __pyx_t_8); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Subtract(__pyx_t_6, __pyx_t_7); + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_8); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_7); + if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = 0; + __pyx_v_b = __pyx_t_9; + } + + /* "total_least_squares.pyx":149 + * b += points[i][1] - m * points[i][0] + * + * b = b / num_points # <<<<<<<<<<<<<< + * return b + * + */ + if (unlikely(__pyx_v_num_points == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(0, 149, __pyx_L1_error) + } + __pyx_v_b = (__pyx_v_b / ((float)__pyx_v_num_points)); + + /* "total_least_squares.pyx":150 + * + * b = b / num_points + * return b # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_b); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 150, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_7); if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_b = __pyx_t_9; - } - - /* "total_least_squares.pyx":149 - * b += points[i][1] - m * points[i][0] - * - * b = b / num_points # <<<<<<<<<<<<<< - * return b - * - */ - if (unlikely(__pyx_v_num_points == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "float division"); - __PYX_ERR(0, 149, __pyx_L1_error) - } - __pyx_v_b = (__pyx_v_b / ((float)__pyx_v_num_points)); - - /* "total_least_squares.pyx":150 - * - * b = b / num_points - * return b # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_b); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 150, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_r = __pyx_t_7; - __pyx_t_7 = 0; - goto __pyx_L0; - - /* "total_least_squares.pyx":142 - * + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L0; + +/* "total_least_squares.pyx":142 + * * # Intercept, b * cdef get_b(points, int num_points, float r, float alpha, float m): # <<<<<<<<<<<<<< * cdef float b = 0 * cdef int i */ - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("total_least_squares.get_b", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; +/* function exit code */ +__pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("total_least_squares.get_b", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; +__pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } /* "total_least_squares.pyx":154 - * + * * # Total Least Squares Fitting Method * cpdef fit_line(points): # <<<<<<<<<<<<<< * cdef int num_points = len(points) - * + * */ -static PyObject *__pyx_pw_19total_least_squares_1fit_line(PyObject *__pyx_self, +static PyObject *__pyx_pw_19total_least_squares_1fit_line(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds + PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, + PyObject *__pyx_kwds #else -PyObject *__pyx_args, PyObject *__pyx_kwds + PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyObject *__pyx_f_19total_least_squares_fit_line(PyObject *__pyx_v_points, CYTHON_UNUSED int __pyx_skip_dispatch) { - int __pyx_v_num_points; - float __pyx_v_x_mean; - float __pyx_v_y_mean; - PyObject *__pyx_v_rho_mat = NULL; - PyObject *__pyx_v_theta_mat = NULL; - PyObject *__pyx_v_w_mat = NULL; - PyObject *__pyx_v_w_sum = NULL; - float __pyx_v_x_weight; - float __pyx_v_y_weight; - float __pyx_v_alpha; - float __pyx_v_r; - float __pyx_v_m; - float __pyx_v_b; - PyObject *__pyx_7genexpr__pyx_v_point = NULL; - PyObject *__pyx_8genexpr1__pyx_v_point = 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 *); - PyObject *__pyx_t_5 = NULL; - float __pyx_t_6; - int __pyx_t_7; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("fit_line", 1); - - /* "total_least_squares.pyx":155 - * # Total Least Squares Fitting Method - * cpdef fit_line(points): - * cdef int num_points = len(points) # <<<<<<<<<<<<<< - * - * cdef float x_mean = sum([point[0] for point in points]) / num_points - */ - __pyx_t_1 = PyObject_Length(__pyx_v_points); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 155, __pyx_L1_error) - __pyx_v_num_points = __pyx_t_1; - - /* "total_least_squares.pyx":157 - * cdef int num_points = len(points) - * - * cdef float x_mean = sum([point[0] for point in points]) / num_points # <<<<<<<<<<<<<< - * cdef float y_mean = sum([point[1] for point in points]) / num_points - * - */ - { /* enter inner scope */ - __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L5_error) - __Pyx_GOTREF(__pyx_t_2); - if (likely(PyList_CheckExact(__pyx_v_points)) || PyTuple_CheckExact(__pyx_v_points)) { - __pyx_t_3 = __pyx_v_points; __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = 0; - __pyx_t_4 = NULL; - } else { - __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_points); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 157, __pyx_L5_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L5_error) - } - for (;;) { - if (likely(!__pyx_t_4)) { - if (likely(PyList_CheckExact(__pyx_t_3))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 157, __pyx_L5_error) - #endif - if (__pyx_t_1 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(0, 157, __pyx_L5_error) - #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 157, __pyx_L5_error) - __Pyx_GOTREF(__pyx_t_5); - #endif +static PyObject *__pyx_f_19total_least_squares_fit_line(PyObject *__pyx_v_points, + CYTHON_UNUSED int __pyx_skip_dispatch) { + int __pyx_v_num_points; + float __pyx_v_x_mean; + float __pyx_v_y_mean; + PyObject *__pyx_v_rho_mat = NULL; + PyObject *__pyx_v_theta_mat = NULL; + PyObject *__pyx_v_w_mat = NULL; + PyObject *__pyx_v_w_sum = NULL; + float __pyx_v_x_weight; + float __pyx_v_y_weight; + float __pyx_v_alpha; + float __pyx_v_r; + float __pyx_v_m; + float __pyx_v_b; + PyObject *__pyx_7genexpr__pyx_v_point = NULL; + PyObject *__pyx_8genexpr1__pyx_v_point = 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 *); + PyObject *__pyx_t_5 = NULL; + float __pyx_t_6; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("fit_line", 1); + + /* "total_least_squares.pyx":155 + * # Total Least Squares Fitting Method + * cpdef fit_line(points): + * cdef int num_points = len(points) # <<<<<<<<<<<<<< + * + * cdef float x_mean = sum([point[0] for point in points]) / num_points + */ + __pyx_t_1 = PyObject_Length(__pyx_v_points); + if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 155, __pyx_L1_error) + __pyx_v_num_points = __pyx_t_1; + + /* "total_least_squares.pyx":157 + * cdef int num_points = len(points) + * + * cdef float x_mean = sum([point[0] for point in points]) / num_points # <<<<<<<<<<<<<< + * cdef float y_mean = sum([point[1] for point in points]) / num_points + * + */ + { /* enter inner scope */ + __pyx_t_2 = PyList_New(0); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(PyList_CheckExact(__pyx_v_points)) || PyTuple_CheckExact(__pyx_v_points)) { + __pyx_t_3 = __pyx_v_points; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_4 = NULL; } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 157, __pyx_L5_error) - #endif - if (__pyx_t_1 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(0, 157, __pyx_L5_error) - #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 157, __pyx_L5_error) - __Pyx_GOTREF(__pyx_t_5); - #endif + __pyx_t_1 = -1; + __pyx_t_3 = PyObject_GetIter(__pyx_v_points); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 157, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L5_error) } - } else { - __pyx_t_5 = __pyx_t_4(__pyx_t_3); - 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, 157, __pyx_L5_error) - } - break; + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 157, __pyx_L5_error) +#endif + if (__pyx_t_1 >= __pyx_temp) break; + } +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __pyx_t_1++; + if (unlikely((0 < 0))) __PYX_ERR(0, 157, __pyx_L5_error) +#else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); + __pyx_t_1++; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 157, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_5); +#endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 157, __pyx_L5_error) +#endif + if (__pyx_t_1 >= __pyx_temp) break; + } +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __pyx_t_1++; + if (unlikely((0 < 0))) __PYX_ERR(0, 157, __pyx_L5_error) +#else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); + __pyx_t_1++; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 157, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_5); +#endif + } + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_3); + 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, 157, __pyx_L5_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_point, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_GetItemInt(__pyx_7genexpr__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 157, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject *)__pyx_t_5))) __PYX_ERR(0, 157, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; } - __Pyx_GOTREF(__pyx_t_5); - } - __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_point, __pyx_t_5); - __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_GetItemInt(__pyx_7genexpr__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 157, __pyx_L5_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 157, __pyx_L5_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_point); __pyx_7genexpr__pyx_v_point = 0; - goto __pyx_L9_exit_scope; + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_point); + __pyx_7genexpr__pyx_v_point = 0; + goto __pyx_L9_exit_scope; __pyx_L5_error:; - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_point); __pyx_7genexpr__pyx_v_point = 0; - goto __pyx_L1_error; + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_point); + __pyx_7genexpr__pyx_v_point = 0; + goto __pyx_L1_error; __pyx_L9_exit_scope:; - } /* exit inner scope */ - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_sum, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_num_points); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_x_mean = __pyx_t_6; - - /* "total_least_squares.pyx":158 - * - * cdef float x_mean = sum([point[0] for point in points]) / num_points - * cdef float y_mean = sum([point[1] for point in points]) / num_points # <<<<<<<<<<<<<< - * - * rho_mat = get_rho_vector(points, num_points) - */ - { /* enter inner scope */ - __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 158, __pyx_L12_error) + } /* exit inner scope */ + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_sum, __pyx_t_2); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_num_points); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_t_2); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (likely(PyList_CheckExact(__pyx_v_points)) || PyTuple_CheckExact(__pyx_v_points)) { - __pyx_t_2 = __pyx_v_points; __Pyx_INCREF(__pyx_t_2); - __pyx_t_1 = 0; - __pyx_t_4 = NULL; - } else { - __pyx_t_1 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_points); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L12_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L12_error) - } - for (;;) { - if (likely(!__pyx_t_4)) { - if (likely(PyList_CheckExact(__pyx_t_2))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 158, __pyx_L12_error) - #endif - if (__pyx_t_1 >= __pyx_temp) 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, 158, __pyx_L12_error) - #else - __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L12_error) - __Pyx_GOTREF(__pyx_t_3); - #endif + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); + if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_v_x_mean = __pyx_t_6; + + /* "total_least_squares.pyx":158 + * + * cdef float x_mean = sum([point[0] for point in points]) / num_points + * cdef float y_mean = sum([point[1] for point in points]) / num_points # <<<<<<<<<<<<<< + * + * rho_mat = get_rho_vector(points, num_points) + */ + { /* enter inner scope */ + __pyx_t_5 = PyList_New(0); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 158, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_5); + if (likely(PyList_CheckExact(__pyx_v_points)) || PyTuple_CheckExact(__pyx_v_points)) { + __pyx_t_2 = __pyx_v_points; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_4 = NULL; } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 158, __pyx_L12_error) - #endif - if (__pyx_t_1 >= __pyx_temp) 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, 158, __pyx_L12_error) - #else - __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L12_error) - __Pyx_GOTREF(__pyx_t_3); - #endif + __pyx_t_1 = -1; + __pyx_t_2 = PyObject_GetIter(__pyx_v_points); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L12_error) } - } 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, 158, __pyx_L12_error) - } - break; + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 158, __pyx_L12_error) +#endif + if (__pyx_t_1 >= __pyx_temp) 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, 158, __pyx_L12_error) +#else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_1); + __pyx_t_1++; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_3); +#endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 158, __pyx_L12_error) +#endif + if (__pyx_t_1 >= __pyx_temp) 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, 158, __pyx_L12_error) +#else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_1); + __pyx_t_1++; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L12_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, 158, __pyx_L12_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_point, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_GetItemInt(__pyx_8genexpr1__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_5, (PyObject *)__pyx_t_3))) __PYX_ERR(0, 158, __pyx_L12_error) + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = 0; } - __Pyx_GOTREF(__pyx_t_3); - } - __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_point, __pyx_t_3); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_GetItemInt(__pyx_8genexpr1__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L12_error) - __Pyx_GOTREF(__pyx_t_3); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_5, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 158, __pyx_L12_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_point); __pyx_8genexpr1__pyx_v_point = 0; - goto __pyx_L16_exit_scope; + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_point); + __pyx_8genexpr1__pyx_v_point = 0; + goto __pyx_L16_exit_scope; __pyx_L12_error:; - __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_point); __pyx_8genexpr1__pyx_v_point = 0; - goto __pyx_L1_error; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_point); + __pyx_8genexpr1__pyx_v_point = 0; + goto __pyx_L1_error; __pyx_L16_exit_scope:; - } /* exit inner scope */ - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_sum, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_num_points); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_y_mean = __pyx_t_6; - - /* "total_least_squares.pyx":160 - * cdef float y_mean = sum([point[1] for point in points]) / num_points - * - * rho_mat = get_rho_vector(points, num_points) # <<<<<<<<<<<<<< - * theta_mat = get_theta_vector(points, num_points) - * - */ - __pyx_t_3 = __pyx_f_19total_least_squares_get_rho_vector(__pyx_v_points, __pyx_v_num_points); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 160, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_v_rho_mat = __pyx_t_3; - __pyx_t_3 = 0; - - /* "total_least_squares.pyx":161 - * - * rho_mat = get_rho_vector(points, num_points) - * theta_mat = get_theta_vector(points, num_points) # <<<<<<<<<<<<<< - * - * w_mat = get_weights(points, num_points, x_mean, y_mean) - */ - __pyx_t_3 = __pyx_f_19total_least_squares_get_theta_vector(__pyx_v_points, __pyx_v_num_points); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_v_theta_mat = __pyx_t_3; - __pyx_t_3 = 0; - - /* "total_least_squares.pyx":163 - * theta_mat = get_theta_vector(points, num_points) - * - * w_mat = get_weights(points, num_points, x_mean, y_mean) # <<<<<<<<<<<<<< - * w_sum = sum(w_mat) - * - */ - __pyx_t_3 = __pyx_f_19total_least_squares_get_weights(__pyx_v_points, __pyx_v_num_points, __pyx_v_x_mean, __pyx_v_y_mean); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_v_w_mat = __pyx_t_3; - __pyx_t_3 = 0; - - /* "total_least_squares.pyx":164 - * - * w_mat = get_weights(points, num_points, x_mean, y_mean) - * w_sum = sum(w_mat) # <<<<<<<<<<<<<< - * - * cdef float x_weight = get_x_weight(w_mat, rho_mat, theta_mat, w_sum, num_points) - */ - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_sum, __pyx_v_w_mat); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_v_w_sum = __pyx_t_3; - __pyx_t_3 = 0; - - /* "total_least_squares.pyx":166 - * w_sum = sum(w_mat) - * - * cdef float x_weight = get_x_weight(w_mat, rho_mat, theta_mat, w_sum, num_points) # <<<<<<<<<<<<<< - * cdef float y_weight = get_y_weight(w_mat, rho_mat, theta_mat, w_sum, num_points) - * - */ - __pyx_t_6 = __pyx_f_19total_least_squares_get_x_weight(__pyx_v_w_mat, __pyx_v_rho_mat, __pyx_v_theta_mat, __pyx_v_w_sum, __pyx_v_num_points); if (unlikely(__pyx_t_6 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 166, __pyx_L1_error) - __pyx_v_x_weight = __pyx_t_6; - - /* "total_least_squares.pyx":167 - * - * cdef float x_weight = get_x_weight(w_mat, rho_mat, theta_mat, w_sum, num_points) - * cdef float y_weight = get_y_weight(w_mat, rho_mat, theta_mat, w_sum, num_points) # <<<<<<<<<<<<<< - * - * cdef float alpha = get_alpha(points, num_points, w_mat, x_weight, y_weight) - */ - __pyx_t_6 = __pyx_f_19total_least_squares_get_y_weight(__pyx_v_w_mat, __pyx_v_rho_mat, __pyx_v_theta_mat, __pyx_v_w_sum, __pyx_v_num_points); if (unlikely(__pyx_t_6 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 167, __pyx_L1_error) - __pyx_v_y_weight = __pyx_t_6; - - /* "total_least_squares.pyx":169 - * cdef float y_weight = get_y_weight(w_mat, rho_mat, theta_mat, w_sum, num_points) - * - * cdef float alpha = get_alpha(points, num_points, w_mat, x_weight, y_weight) # <<<<<<<<<<<<<< - * cdef float r = get_r(x_weight, y_weight, alpha) - * - */ - __pyx_t_6 = __pyx_f_19total_least_squares_get_alpha(__pyx_v_points, __pyx_v_num_points, __pyx_v_w_mat, __pyx_v_x_weight, __pyx_v_y_weight); if (unlikely(__pyx_t_6 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 169, __pyx_L1_error) - __pyx_v_alpha = __pyx_t_6; - - /* "total_least_squares.pyx":170 - * - * cdef float alpha = get_alpha(points, num_points, w_mat, x_weight, y_weight) - * cdef float r = get_r(x_weight, y_weight, alpha) # <<<<<<<<<<<<<< - * - * if r < 0: - */ - __pyx_t_6 = __pyx_f_19total_least_squares_get_r(__pyx_v_x_weight, __pyx_v_y_weight, __pyx_v_alpha); if (unlikely(__pyx_t_6 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 170, __pyx_L1_error) - __pyx_v_r = __pyx_t_6; - - /* "total_least_squares.pyx":172 - * cdef float r = get_r(x_weight, y_weight, alpha) - * - * if r < 0: # <<<<<<<<<<<<<< - * r = -r - * alpha += math.pi/2 - */ - __pyx_t_7 = (__pyx_v_r < 0.0); - if (__pyx_t_7) { - - /* "total_least_squares.pyx":173 - * - * if r < 0: - * r = -r # <<<<<<<<<<<<<< - * alpha += math.pi/2 - * - */ - __pyx_v_r = (-__pyx_v_r); - - /* "total_least_squares.pyx":174 - * if r < 0: - * r = -r - * alpha += math.pi/2 # <<<<<<<<<<<<<< - * - * cdef float m = get_m(alpha, y_weight) - */ - __pyx_v_alpha = (__pyx_v_alpha + (((double)M_PI) / 2.0)); + } /* exit inner scope */ + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_sum, __pyx_t_5); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_num_points); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_t_5); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_3); + if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = 0; + __pyx_v_y_mean = __pyx_t_6; + + /* "total_least_squares.pyx":160 + * cdef float y_mean = sum([point[1] for point in points]) / num_points + * + * rho_mat = get_rho_vector(points, num_points) # <<<<<<<<<<<<<< + * theta_mat = get_theta_vector(points, num_points) + * + */ + __pyx_t_3 = __pyx_f_19total_least_squares_get_rho_vector(__pyx_v_points, __pyx_v_num_points); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rho_mat = __pyx_t_3; + __pyx_t_3 = 0; + + /* "total_least_squares.pyx":161 + * + * rho_mat = get_rho_vector(points, num_points) + * theta_mat = get_theta_vector(points, num_points) # <<<<<<<<<<<<<< + * + * w_mat = get_weights(points, num_points, x_mean, y_mean) + */ + __pyx_t_3 = __pyx_f_19total_least_squares_get_theta_vector(__pyx_v_points, __pyx_v_num_points); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_theta_mat = __pyx_t_3; + __pyx_t_3 = 0; + + /* "total_least_squares.pyx":163 + * theta_mat = get_theta_vector(points, num_points) + * + * w_mat = get_weights(points, num_points, x_mean, y_mean) # <<<<<<<<<<<<<< + * w_sum = sum(w_mat) + * + */ + __pyx_t_3 = + __pyx_f_19total_least_squares_get_weights(__pyx_v_points, __pyx_v_num_points, __pyx_v_x_mean, __pyx_v_y_mean); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_w_mat = __pyx_t_3; + __pyx_t_3 = 0; + + /* "total_least_squares.pyx":164 + * + * w_mat = get_weights(points, num_points, x_mean, y_mean) + * w_sum = sum(w_mat) # <<<<<<<<<<<<<< + * + * cdef float x_weight = get_x_weight(w_mat, rho_mat, theta_mat, w_sum, num_points) + */ + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_sum, __pyx_v_w_mat); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_w_sum = __pyx_t_3; + __pyx_t_3 = 0; + + /* "total_least_squares.pyx":166 + * w_sum = sum(w_mat) + * + * cdef float x_weight = get_x_weight(w_mat, rho_mat, theta_mat, w_sum, num_points) # <<<<<<<<<<<<<< + * cdef float y_weight = get_y_weight(w_mat, rho_mat, theta_mat, w_sum, num_points) + * + */ + __pyx_t_6 = __pyx_f_19total_least_squares_get_x_weight(__pyx_v_w_mat, __pyx_v_rho_mat, __pyx_v_theta_mat, + __pyx_v_w_sum, __pyx_v_num_points); + if (unlikely(__pyx_t_6 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 166, __pyx_L1_error) + __pyx_v_x_weight = __pyx_t_6; + + /* "total_least_squares.pyx":167 + * + * cdef float x_weight = get_x_weight(w_mat, rho_mat, theta_mat, w_sum, num_points) + * cdef float y_weight = get_y_weight(w_mat, rho_mat, theta_mat, w_sum, num_points) # <<<<<<<<<<<<<< + * + * cdef float alpha = get_alpha(points, num_points, w_mat, x_weight, y_weight) + */ + __pyx_t_6 = __pyx_f_19total_least_squares_get_y_weight(__pyx_v_w_mat, __pyx_v_rho_mat, __pyx_v_theta_mat, + __pyx_v_w_sum, __pyx_v_num_points); + if (unlikely(__pyx_t_6 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 167, __pyx_L1_error) + __pyx_v_y_weight = __pyx_t_6; + + /* "total_least_squares.pyx":169 + * cdef float y_weight = get_y_weight(w_mat, rho_mat, theta_mat, w_sum, num_points) + * + * cdef float alpha = get_alpha(points, num_points, w_mat, x_weight, y_weight) # <<<<<<<<<<<<<< + * cdef float r = get_r(x_weight, y_weight, alpha) + * + */ + __pyx_t_6 = __pyx_f_19total_least_squares_get_alpha(__pyx_v_points, __pyx_v_num_points, __pyx_v_w_mat, + __pyx_v_x_weight, __pyx_v_y_weight); + if (unlikely(__pyx_t_6 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 169, __pyx_L1_error) + __pyx_v_alpha = __pyx_t_6; + + /* "total_least_squares.pyx":170 + * + * cdef float alpha = get_alpha(points, num_points, w_mat, x_weight, y_weight) + * cdef float r = get_r(x_weight, y_weight, alpha) # <<<<<<<<<<<<<< + * + * if r < 0: + */ + __pyx_t_6 = __pyx_f_19total_least_squares_get_r(__pyx_v_x_weight, __pyx_v_y_weight, __pyx_v_alpha); + if (unlikely(__pyx_t_6 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 170, __pyx_L1_error) + __pyx_v_r = __pyx_t_6; /* "total_least_squares.pyx":172 - * cdef float r = get_r(x_weight, y_weight, alpha) - * - * if r < 0: # <<<<<<<<<<<<<< - * r = -r - * alpha += math.pi/2 - */ - } - - /* "total_least_squares.pyx":176 - * alpha += math.pi/2 - * - * cdef float m = get_m(alpha, y_weight) # <<<<<<<<<<<<<< - * cdef float b = get_b(points, num_points, r, alpha, m) - * - */ - __pyx_t_6 = __pyx_f_19total_least_squares_get_m(__pyx_v_alpha, __pyx_v_y_weight); if (unlikely(__pyx_t_6 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 176, __pyx_L1_error) - __pyx_v_m = __pyx_t_6; - - /* "total_least_squares.pyx":177 - * - * cdef float m = get_m(alpha, y_weight) - * cdef float b = get_b(points, num_points, r, alpha, m) # <<<<<<<<<<<<<< - * - * return ([m, b]) - */ - __pyx_t_3 = __pyx_f_19total_least_squares_get_b(__pyx_v_points, __pyx_v_num_points, __pyx_v_r, __pyx_v_alpha, __pyx_v_m); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_b = __pyx_t_6; - - /* "total_least_squares.pyx":179 - * cdef float b = get_b(points, num_points, r, alpha, m) - * - * return ([m, b]) # <<<<<<<<<<<<<< - * - * # Notes - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_m); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_b); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 179, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 179, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_5)) __PYX_ERR(0, 179, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_5 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "total_least_squares.pyx":154 - * + * cdef float r = get_r(x_weight, y_weight, alpha) + * + * if r < 0: # <<<<<<<<<<<<<< + * r = -r + * alpha += math.pi/2 + */ + __pyx_t_7 = (__pyx_v_r < 0.0); + if (__pyx_t_7) { + /* "total_least_squares.pyx":173 + * + * if r < 0: + * r = -r # <<<<<<<<<<<<<< + * alpha += math.pi/2 + * + */ + __pyx_v_r = (-__pyx_v_r); + + /* "total_least_squares.pyx":174 + * if r < 0: + * r = -r + * alpha += math.pi/2 # <<<<<<<<<<<<<< + * + * cdef float m = get_m(alpha, y_weight) + */ + __pyx_v_alpha = (__pyx_v_alpha + (((double)M_PI) / 2.0)); + + /* "total_least_squares.pyx":172 + * cdef float r = get_r(x_weight, y_weight, alpha) + * + * if r < 0: # <<<<<<<<<<<<<< + * r = -r + * alpha += math.pi/2 + */ + } + + /* "total_least_squares.pyx":176 + * alpha += math.pi/2 + * + * cdef float m = get_m(alpha, y_weight) # <<<<<<<<<<<<<< + * cdef float b = get_b(points, num_points, r, alpha, m) + * + */ + __pyx_t_6 = __pyx_f_19total_least_squares_get_m(__pyx_v_alpha, __pyx_v_y_weight); + if (unlikely(__pyx_t_6 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 176, __pyx_L1_error) + __pyx_v_m = __pyx_t_6; + + /* "total_least_squares.pyx":177 + * + * cdef float m = get_m(alpha, y_weight) + * cdef float b = get_b(points, num_points, r, alpha, m) # <<<<<<<<<<<<<< + * + * return ([m, b]) + */ + __pyx_t_3 = + __pyx_f_19total_least_squares_get_b(__pyx_v_points, __pyx_v_num_points, __pyx_v_r, __pyx_v_alpha, __pyx_v_m); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_3); + if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = 0; + __pyx_v_b = __pyx_t_6; + + /* "total_least_squares.pyx":179 + * cdef float b = get_b(points, num_points, r, alpha, m) + * + * return ([m, b]) # <<<<<<<<<<<<<< + * + * # Notes + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_m); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_b); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = PyList_New(2); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_5)) __PYX_ERR(0, 179, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + +/* "total_least_squares.pyx":154 + * * # Total Least Squares Fitting Method * cpdef fit_line(points): # <<<<<<<<<<<<<< * cdef int num_points = len(points) - * + * */ - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("total_least_squares.fit_line", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_rho_mat); - __Pyx_XDECREF(__pyx_v_theta_mat); - __Pyx_XDECREF(__pyx_v_w_mat); - __Pyx_XDECREF(__pyx_v_w_sum); - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_point); - __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_point); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; +/* function exit code */ +__pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("total_least_squares.fit_line", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; +__pyx_L0:; + __Pyx_XDECREF(__pyx_v_rho_mat); + __Pyx_XDECREF(__pyx_v_theta_mat); + __Pyx_XDECREF(__pyx_v_w_mat); + __Pyx_XDECREF(__pyx_v_w_sum); + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_point); + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_point); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } /* Python wrapper */ -static PyObject *__pyx_pw_19total_least_squares_1fit_line(PyObject *__pyx_self, +static PyObject *__pyx_pw_19total_least_squares_1fit_line(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds + PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, + PyObject *__pyx_kwds #else -PyObject *__pyx_args, PyObject *__pyx_kwds + PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ -static PyMethodDef __pyx_mdef_19total_least_squares_1fit_line = {"fit_line", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_19total_least_squares_1fit_line, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_19total_least_squares_1fit_line(PyObject *__pyx_self, +static PyMethodDef __pyx_mdef_19total_least_squares_1fit_line = { + "fit_line", (PyCFunction)(void *)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_19total_least_squares_1fit_line, + __Pyx_METH_FASTCALL | METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_19total_least_squares_1fit_line(PyObject *__pyx_self, #if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds + PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, + PyObject *__pyx_kwds #else -PyObject *__pyx_args, PyObject *__pyx_kwds + PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { - PyObject *__pyx_v_points = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("fit_line (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_points,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_points)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; + PyObject *__pyx_v_points = 0; +#if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; +#endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fit_line (wrapper)", 0); +#if !CYTHON_METH_FASTCALL +#if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); +#else + __pyx_nargs = PyTuple_Size(__pyx_args); + if (unlikely(__pyx_nargs < 0)) return NULL; +#endif +#endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_points, 0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: + break; + default: + goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_points)) != + 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } else if (unlikely(PyErr_Occurred())) + __PYX_ERR(0, 154, __pyx_L3_error) + else + goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, + kwd_pos_args, "fit_line") < 0)) + __PYX_ERR(0, 154, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 154, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "fit_line") < 0)) __PYX_ERR(0, 154, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v_points = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("fit_line", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 154, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("total_least_squares.fit_line", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_19total_least_squares_fit_line(__pyx_self, __pyx_v_points); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; + __pyx_v_points = values[0]; + } + goto __pyx_L6_skip; +__pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("fit_line", 1, 1, 1, __pyx_nargs); + __PYX_ERR(0, 154, __pyx_L3_error) +__pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; +__pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp = 0; __pyx_temp < (Py_ssize_t)(sizeof(values) / sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("total_least_squares.fit_line", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; +__pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_19total_least_squares_fit_line(__pyx_self, __pyx_v_points); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp = 0; __pyx_temp < (Py_ssize_t)(sizeof(values) / sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; } static PyObject *__pyx_pf_19total_least_squares_fit_line(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_points) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("fit_line", 1); - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19total_least_squares_fit_line(__pyx_v_points, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("total_least_squares.fit_line", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyMethodDef __pyx_methods[] = { - {0, 0, 0, 0} -}; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("fit_line", 1); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_19total_least_squares_fit_line(__pyx_v_points, 0); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + +/* function exit code */ +__pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("total_least_squares.fit_line", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; +__pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyMethodDef __pyx_methods[] = {{0, 0, 0, 0}}; #ifndef CYTHON_SMALL_CODE #if defined(__clang__) - #define CYTHON_SMALL_CODE +#define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) - #define CYTHON_SMALL_CODE __attribute__((cold)) +#define CYTHON_SMALL_CODE __attribute__((cold)) #else - #define CYTHON_SMALL_CODE +#define CYTHON_SMALL_CODE #endif #endif /* #### Code section: pystring_table ### */ static int __Pyx_CreateStringTabAndInitStrings(void) { - __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_n_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 1}, - {&__pyx_n_s__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 1, 1}, - {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_fit_line, __pyx_k_fit_line, sizeof(__pyx_k_fit_line), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_initializing, __pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 0, 1, 1}, - {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_maxsize, __pyx_k_maxsize, sizeof(__pyx_k_maxsize), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_points, __pyx_k_points, sizeof(__pyx_k_points), 0, 0, 1, 1}, - {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, - {&__pyx_n_s_spec, __pyx_k_spec, sizeof(__pyx_k_spec), 0, 0, 1, 1}, - {&__pyx_n_s_sum, __pyx_k_sum, sizeof(__pyx_k_sum), 0, 0, 1, 1}, - {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_total_least_squares, __pyx_k_total_least_squares, sizeof(__pyx_k_total_least_squares), 0, 0, 1, 1}, - {&__pyx_kp_s_total_least_squares_pyx, __pyx_k_total_least_squares_pyx, sizeof(__pyx_k_total_least_squares_pyx), 0, 0, 1, 0}, - {0, 0, 0, 0, 0, 0, 0} - }; - return __Pyx_InitStrings(__pyx_string_tab); + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 1}, + {&__pyx_n_s__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 1, 1}, + {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_fit_line, __pyx_k_fit_line, sizeof(__pyx_k_fit_line), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_initializing, __pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 0, 1, 1}, + {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_maxsize, __pyx_k_maxsize, sizeof(__pyx_k_maxsize), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_points, __pyx_k_points, sizeof(__pyx_k_points), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_spec, __pyx_k_spec, sizeof(__pyx_k_spec), 0, 0, 1, 1}, + {&__pyx_n_s_sum, __pyx_k_sum, sizeof(__pyx_k_sum), 0, 0, 1, 1}, + {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_total_least_squares, __pyx_k_total_least_squares, sizeof(__pyx_k_total_least_squares), 0, 0, 1, 1}, + {&__pyx_kp_s_total_least_squares_pyx, __pyx_k_total_least_squares_pyx, sizeof(__pyx_k_total_least_squares_pyx), + 0, 0, 1, 0}, + {0, 0, 0, 0, 0, 0, 0}}; + return __Pyx_InitStrings(__pyx_string_tab); } /* #### Code section: cached_builtins ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 21, __pyx_L1_error) - __pyx_builtin_sum = __Pyx_GetBuiltinName(__pyx_n_s_sum); if (!__pyx_builtin_sum) __PYX_ERR(0, 157, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); + if (!__pyx_builtin_range) __PYX_ERR(0, 21, __pyx_L1_error) + __pyx_builtin_sum = __Pyx_GetBuiltinName(__pyx_n_s_sum); + if (!__pyx_builtin_sum) __PYX_ERR(0, 157, __pyx_L1_error) + return 0; +__pyx_L1_error:; + return -1; } /* #### Code section: cached_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - /* "total_least_squares.pyx":154 - * - * # Total Least Squares Fitting Method - * cpdef fit_line(points): # <<<<<<<<<<<<<< - * cdef int num_points = len(points) - * - */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_n_s_points); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); - __pyx_codeobj__3 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_total_least_squares_pyx, __pyx_n_s_fit_line, 154, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; + __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "total_least_squares.pyx":154 + * + * # Total Least Squares Fitting Method + * cpdef fit_line(points): # <<<<<<<<<<<<<< + * cdef int num_points = len(points) + * + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_n_s_points); + if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + __pyx_codeobj__3 = + (PyObject *)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED | CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, + __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, + __pyx_kp_s_total_least_squares_pyx, __pyx_n_s_fit_line, 154, __pyx_empty_bytes); + if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; +__pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; } /* #### Code section: init_constants ### */ static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { - if (__Pyx_CreateStringTabAndInitStrings() < 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) - return 0; - __pyx_L1_error:; - return -1; + if (__Pyx_CreateStringTabAndInitStrings() < 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) + return 0; +__pyx_L1_error:; + return -1; } /* #### Code section: init_globals ### */ -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - return 0; -} +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { return 0; } /* #### Code section: init_module ### */ -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +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_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; + __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; + __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; + __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 ---*/ - __Pyx_RefNannyFinishContext(); - return 0; + __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; } 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; + __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; + __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; + __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; } - #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_total_least_squares(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_total_least_squares}, - {0, NULL} -}; +static PyObject *__pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_total_least_squares(PyObject *module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = {{Py_mod_create, (void *)__pyx_pymod_create}, + {Py_mod_exec, (void *)__pyx_pymod_exec_total_least_squares}, + {0, NULL}}; #endif #ifdef __cplusplus namespace { - struct PyModuleDef __pyx_moduledef = - #else - static struct PyModuleDef __pyx_moduledef = - #endif - { - PyModuleDef_HEAD_INIT, - "total_least_squares", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #elif CYTHON_USE_MODULE_STATE - sizeof(__pyx_mstate), /* 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 - #if CYTHON_USE_MODULE_STATE - __pyx_m_traverse, /* m_traverse */ - __pyx_m_clear, /* m_clear */ - NULL /* m_free */ - #else - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ - #endif - }; - #ifdef __cplusplus +struct PyModuleDef __pyx_moduledef = +#else +static struct PyModuleDef __pyx_moduledef = +#endif +{ PyModuleDef_HEAD_INIT, + "total_least_squares", + 0, /* m_doc */ +#if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ +#elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* 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 +#if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ +#else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +#endif +}; +#ifdef __cplusplus } /* anonymous namespace */ #endif #endif @@ -4676,7 +5033,6 @@ namespace { #endif #endif - #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC inittotal_least_squares(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC inittotal_least_squares(void) @@ -4685,23 +5041,23 @@ __Pyx_PyMODINIT_FUNC PyInit_total_least_squares(void) CYTHON_SMALL_CODE; /*proto __Pyx_PyMODINIT_FUNC PyInit_total_least_squares(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { - return PyModuleDef_Init(&__pyx_moduledef); + return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 +#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 +#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 +#endif { PyErr_SetString( PyExc_ImportError, @@ -4711,9 +5067,11 @@ static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { return 0; } #if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char *from_name, + const char *to_name, int allow_none) #else -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) +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) #endif { PyObject *value = PyObject_GetAttrString(spec, from_name); @@ -4734,13 +5092,11 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject } return result; } -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { +static CYTHON_SMALL_CODE PyObject *__pyx_pymod_create(PyObject *spec, PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; CYTHON_UNUSED_VAR(def); - if (__Pyx_check_single_interpreter()) - return NULL; - if (__pyx_m) - return __Pyx_NewRef(__pyx_m); + 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); @@ -4762,214 +5118,229 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDe return NULL; } - static CYTHON_SMALL_CODE int __pyx_pymod_exec_total_least_squares(PyObject *__pyx_pyinit_module) #endif #endif { - int stringtab_initialized = 0; - #if CYTHON_USE_MODULE_STATE - int pystate_addmodule_run = 0; - #endif - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannyDeclarations - #if CYTHON_PEP489_MULTI_PHASE_INIT - if (__pyx_m) { - if (__pyx_m == __pyx_pyinit_module) return 0; - PyErr_SetString(PyExc_RuntimeError, "Module 'total_least_squares' 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 - /*--- 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("total_least_squares", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #elif CYTHON_USE_MODULE_STATE - __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - { - int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); - __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "total_least_squares" pseudovariable */ - if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - pystate_addmodule_run = 1; - } - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #endif - CYTHON_UNUSED_VAR(__pyx_t_1); - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #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_total_least_squares(void)", 0); - if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 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(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - PyEval_InitThreads(); - #endif - /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - stringtab_initialized = 1; - 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_total_least_squares) { - 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, "total_least_squares")) { - if (unlikely((PyDict_SetItemString(modules, "total_least_squares", __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(); - (void)__Pyx_modinit_type_init_code(); - (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 - - /* "total_least_squares.pyx":3 - * # Modules - * cimport libc.math as math - * import sys # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_sys, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "total_least_squares.pyx":154 - * - * # Total Least Squares Fitting Method - * cpdef fit_line(points): # <<<<<<<<<<<<<< - * cdef int num_points = len(points) - * - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_19total_least_squares_1fit_line, 0, __pyx_n_s_fit_line, NULL, __pyx_n_s_total_least_squares, __pyx_d, ((PyObject *)__pyx_codeobj__3)); 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_fit_line, __pyx_t_2) < 0) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "total_least_squares.pyx":1 - * # Modules # <<<<<<<<<<<<<< - * cimport libc.math as math - * import sys - */ - __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_2); - if (__pyx_m) { - if (__pyx_d && stringtab_initialized) { - __Pyx_AddTraceback("init total_least_squares", __pyx_clineno, __pyx_lineno, __pyx_filename); - } - #if !CYTHON_USE_MODULE_STATE - Py_CLEAR(__pyx_m); - #else - Py_DECREF(__pyx_m); - if (pystate_addmodule_run) { - PyObject *tp, *value, *tb; - PyErr_Fetch(&tp, &value, &tb); - PyState_RemoveModule(&__pyx_moduledef); - PyErr_Restore(tp, value, tb); - } - #endif - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init total_least_squares"); - } - __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 + int stringtab_initialized = 0; +#if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; +#endif + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations +#if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, + "Module 'total_least_squares' 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 +/*--- 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("total_least_squares", __pyx_methods, 0, 0, PYTHON_API_VERSION); + Py_XINCREF(__pyx_m); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) +#elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) { + int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "total_least_squares" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } +#else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) +#endif +#endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); + if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); + if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *)"cython_runtime"); + if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) +#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_total_least_squares(void)", 0); + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), + CYTHON_COMPILING_IN_LIMITED_API) < 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(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) +#endif +#ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) +#endif +#ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) +#endif +#ifdef __Pyx_Generator_USED + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) +#endif +#ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) +#endif +#ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) +#endif +/*--- Library function declarations ---*/ +/*--- Threads initialization code ---*/ +#if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); +#endif + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; + 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_total_least_squares) { + 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, "total_least_squares")) { + if (unlikely((PyDict_SetItemString(modules, "total_least_squares", __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(); + (void)__Pyx_modinit_type_init_code(); + (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 + + /* "total_least_squares.pyx":3 + * # Modules + * cimport libc.math as math + * import sys # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_sys, NULL); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = 0; + + /* "total_least_squares.pyx":154 + * + * # Total Least Squares Fitting Method + * cpdef fit_line(points): # <<<<<<<<<<<<<< + * cdef int num_points = len(points) + * + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_19total_least_squares_1fit_line, 0, __pyx_n_s_fit_line, NULL, + __pyx_n_s_total_least_squares, __pyx_d, ((PyObject *)__pyx_codeobj__3)); + 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_fit_line, __pyx_t_2) < 0) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = 0; + + /* "total_least_squares.pyx":1 + * # Modules # <<<<<<<<<<<<<< + * cimport libc.math as math + * import sys + */ + __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_2); + if (__pyx_m) { + if (__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init total_least_squares", __pyx_clineno, __pyx_lineno, __pyx_filename); + } +#if !CYTHON_USE_MODULE_STATE + Py_CLEAR(__pyx_m); +#else + Py_DECREF(__pyx_m); + if (pystate_addmodule_run) { + PyObject *tp, *value, *tb; + PyErr_Fetch(&tp, &value, &tb); + PyState_RemoveModule(&__pyx_moduledef); + PyErr_Restore(tp, value, tb); + } +#endif + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init total_least_squares"); + } +__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 } /* #### Code section: cleanup_globals ### */ /* #### Code section: cleanup_module ### */ /* #### Code section: main_method ### */ /* #### Code section: utility_code_pragmas ### */ #ifdef _MSC_VER -#pragma warning( push ) +#pragma warning(push) /* Warning 4127: conditional expression is constant * Cython uses constant conditional expressions to allow in inline functions to be optimized at * compile-time, so this warning is not useful */ -#pragma warning( disable : 4127 ) +#pragma warning(disable : 4127) #endif - - /* #### Code section: utility_code_def ### */ /* --- Runtime support code --- */ @@ -4996,53 +5367,54 @@ static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 - for (i=0; i= 0x030C00A6 PyObject *current_exception = tstate->current_exception; if (unlikely(!current_exception)) return 0; - exc_type = (PyObject*) Py_TYPE(current_exception); + exc_type = (PyObject *)Py_TYPE(current_exception); if (exc_type == err) return 1; #else exc_type = tstate->curexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; #endif - #if CYTHON_AVOID_BORROWED_REFS +#if CYTHON_AVOID_BORROWED_REFS Py_INCREF(exc_type); - #endif +#endif if (unlikely(PyTuple_Check(err))) { result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); } else { result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } - #if CYTHON_AVOID_BORROWED_REFS +#if CYTHON_AVOID_BORROWED_REFS Py_DECREF(exc_type); - #endif +#endif return result; } #endif /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, + PyObject *tb) { #if PY_VERSION_HEX >= 0x030C00A6 PyObject *tmp_value; - assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + assert(type == NULL || (value != NULL && type == (PyObject *)Py_TYPE(value))); if (value) { - #if CYTHON_COMPILING_IN_CPYTHON - if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) - #endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject *)value)->traceback != tb)) +#endif PyException_SetTraceback(value, tb); } tmp_value = tstate->current_exception; @@ -5063,23 +5435,24 @@ static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObjec Py_XDECREF(tmp_tb); #endif } -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, + PyObject **tb) { #if PY_VERSION_HEX >= 0x030C00A6 - PyObject* exc_value; + PyObject *exc_value; exc_value = tstate->current_exception; tstate->current_exception = 0; *value = exc_value; *type = NULL; *tb = NULL; if (exc_value) { - *type = (PyObject*) Py_TYPE(exc_value); + *type = (PyObject *)Py_TYPE(exc_value); Py_INCREF(*type); - #if CYTHON_COMPILING_IN_CPYTHON - *tb = ((PyBaseExceptionObject*) exc_value)->traceback; +#if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject *)exc_value)->traceback; Py_XINCREF(*tb); - #else +#else *tb = PyException_GetTraceback(exc_value); - #endif +#endif } #else *type = tstate->curexc_type; @@ -5094,13 +5467,11 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject /* 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); +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)); + if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } @@ -5109,20 +5480,18 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject /* PyObjectGetAttrStrNoError */ #if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - __Pyx_PyErr_Clear(); + __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (likely(__Pyx_PyErr_ExceptionMatches( + PyExc_AttributeError))) __Pyx_PyErr_Clear(); } #endif -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetAttrStrNoError(PyObject *obj, PyObject *attr_name) { PyObject *result; #if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 - (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + (void)PyObject_GetOptionalAttr(obj, attr_name, &result); return result; #else #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 - PyTypeObject* tp = Py_TYPE(obj); + PyTypeObject *tp = Py_TYPE(obj); if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); } @@ -5137,29 +5506,28 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, P /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); + PyObject *result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); if (unlikely(!result) && !PyErr_Occurred()) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); + "name '%U' is not defined", name); #else - "name '%.200s' is not defined", PyString_AS_STRING(name)); + "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* GetItemInt */ -static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject *j) { PyObject *r; if (unlikely(!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) { +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)) { @@ -5175,9 +5543,8 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_ 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) { +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)) { @@ -5204,8 +5571,7 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, Py_INCREF(r); return r; } - } - else if (PyTuple_CheckExact(o)) { + } 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); @@ -5228,8 +5594,7 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, if (likely(l >= 0)) { i += l; } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return NULL; + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } @@ -5255,17 +5620,17 @@ static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { 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); + 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) { +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; + 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 @@ -5280,7 +5645,7 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + 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); @@ -5315,8 +5680,7 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL -static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, - PyObject *globals) { +static PyObject *__Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; @@ -5337,7 +5701,7 @@ static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args Py_INCREF(*args); fastlocals[i] = *args++; } - result = PyEval_EvalFrameEx(f,0); + result = PyEval_EvalFrameEx(f, 0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; @@ -5358,31 +5722,28 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) { return NULL; } - #else +#else if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { return NULL; } - #endif +#endif if ( #if PY_MAJOR_VERSION >= 3 - co->co_kwonlyargcount == 0 && + co->co_kwonlyargcount == 0 && #endif - likely(kwargs == NULL || nk == 0) && - co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + 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)) { + } 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); + result = __Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } @@ -5395,14 +5756,13 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; - while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + while (PyDict_Next(kwargs, &pos, &k[i], &k[i + 1])) { Py_INCREF(k[i]); - Py_INCREF(k[i+1]); + Py_INCREF(k[i + 1]); i += 2; } nk = i / 2; - } - else { + } else { kwtuple = NULL; k = NULL; } @@ -5413,21 +5773,15 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); - } - else { + } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); + result = PyEval_EvalCodeEx((PyObject *)co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, + kwdefs, closure); #else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: @@ -5438,24 +5792,19 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { +static CYTHON_INLINE PyObject *__Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = Py_TYPE(func)->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) - return NULL; - #endif + if (unlikely(!call)) return PyObject_Call(func, arg, kw); +#if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) return NULL; +#else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) return NULL; +#endif result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); + PyErr_SetString(PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } @@ -5463,24 +5812,20 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { +static CYTHON_INLINE PyObject *__Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); - self = __Pyx_CyOrPyCFunction_GET_SELF(func); - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) - return NULL; - #endif + self = __Pyx_CyOrPyCFunction_GET_SELF(func); +#if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char *)" while calling a Python object"))) return NULL; +#else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) return NULL; +#endif result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); + PyErr_SetString(PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } @@ -5488,7 +5833,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject /* PyObjectFastCall */ #if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API -static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { +static PyObject *__Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { PyObject *argstuple; PyObject *result = 0; size_t i; @@ -5499,25 +5844,25 @@ static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **arg if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; } result = __Pyx_PyObject_Call(func, argstuple, kwargs); - bad: +bad: Py_DECREF(argstuple); return result; } #endif -static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { +static CYTHON_INLINE PyObject *__Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, + PyObject *kwargs) { Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); #if CYTHON_COMPILING_IN_CPYTHON if (nargs == 0 && kwargs == NULL) { - if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + if (__Pyx_CyOrPyCFunction_Check(func) && likely(__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) return __Pyx_PyObject_CallMethO(func, NULL); - } - else if (nargs == 1 && kwargs == NULL) { - if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + } else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely(__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) return __Pyx_PyObject_CallMethO(func, args[0]); } #endif - #if PY_VERSION_HEX < 0x030800B1 - #if CYTHON_FAST_PYCCALL +#if PY_VERSION_HEX < 0x030800B1 +#if CYTHON_FAST_PYCCALL if (PyCFunction_Check(func)) { if (kwargs) { return _PyCFunction_FastCallDict(func, args, nargs, kwargs); @@ -5525,54 +5870,55 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObj return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); } } - #if PY_VERSION_HEX >= 0x030700A1 +#if PY_VERSION_HEX >= 0x030700A1 if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); } - #endif - #endif - #if CYTHON_FAST_PYCALL +#endif +#endif +#if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); } - #endif - #endif +#endif +#endif if (kwargs == NULL) { - #if CYTHON_VECTORCALL - #if PY_VERSION_HEX < 0x03090000 +#if CYTHON_VECTORCALL +#if PY_VERSION_HEX < 0x03090000 vectorcallfunc f = _PyVectorcall_Function(func); - #else +#else vectorcallfunc f = PyVectorcall_Function(func); - #endif +#endif if (f) { return f(func, args, (size_t)nargs, NULL); } - #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL +#elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL if (__Pyx_CyFunction_CheckExact(func)) { __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); if (f) return f(func, args, (size_t)nargs, NULL); } - #endif +#endif } if (nargs == 0) { return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); } - #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); - #else +#else return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); - #endif +#endif } /* PyObjectCallOneArg */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +static CYTHON_INLINE PyObject *__Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *args[2] = {NULL, arg}; - return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + return __Pyx_PyObject_FastCall(func, args + 1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } /* TupleAndListFromArray */ #if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject **CYTHON_RESTRICT dest, + Py_ssize_t length) { PyObject *v; Py_ssize_t i; for (i = 0; i < length; i++) { @@ -5580,9 +5926,7 @@ static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRI Py_INCREF(v); } } -static CYTHON_INLINE PyObject * -__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) -{ +static CYTHON_INLINE PyObject *__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) { PyObject *res; if (n <= 0) { Py_INCREF(__pyx_empty_tuple); @@ -5590,25 +5934,23 @@ __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) } res = PyTuple_New(n); if (unlikely(res == NULL)) return NULL; - __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + __Pyx_copy_object_array(src, ((PyTupleObject *)res)->ob_item, n); return res; } -static CYTHON_INLINE PyObject * -__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) -{ +static CYTHON_INLINE PyObject *__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) { PyObject *res; if (n <= 0) { return PyList_New(0); } res = PyList_New(n); if (unlikely(res == NULL)) return NULL; - __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + __Pyx_copy_object_array(src, ((PyListObject *)res)->ob_item, n); return res; } #endif /* BytesEquals */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject *s1, PyObject *s2, int equals) { #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API return PyObject_RichCompareBool(s1, s2, equals); #else @@ -5617,8 +5959,7 @@ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int 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); + 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]) { @@ -5629,8 +5970,8 @@ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int eq int result; #if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) Py_hash_t hash1, hash2; - hash1 = ((PyBytesObject*)s1)->ob_shash; - hash2 = ((PyBytesObject*)s2)->ob_shash; + hash1 = ((PyBytesObject *)s1)->ob_shash; + hash2 = ((PyBytesObject *)s2)->ob_shash; if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { return (equals == Py_NE); } @@ -5644,9 +5985,8 @@ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int eq return (equals == Py_NE); } else { int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - if (!py_result) - return -1; + 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; @@ -5655,12 +5995,12 @@ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int eq } /* UnicodeEquals */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject *s1, PyObject *s2, int equals) { #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 - PyObject* owned_ref = NULL; + PyObject *owned_ref = NULL; #endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { @@ -5671,14 +6011,12 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int #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; + 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; + if (unlikely(!owned_ref)) return -1; s1 = owned_ref; s1_is_unicode = 1; } else if (((!s2_is_unicode) & (!s1_is_unicode))) { @@ -5689,8 +6027,7 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int Py_ssize_t length; int kind; void *data1, *data2; - if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) - return -1; + 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; @@ -5698,13 +6035,13 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int #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 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; } @@ -5722,9 +6059,9 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); - #endif +#endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { @@ -5733,40 +6070,36 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int goto return_ne; } else { int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - #if PY_MAJOR_VERSION < 3 + PyObject *py_result = PyObject_RichCompare(s1, s2, equals); +#if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); - #endif - if (!py_result) - return -1; +#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 +#if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); - #endif +#endif return (equals == Py_EQ); return_ne: - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); - #endif +#endif return (equals == Py_NE); #endif } /* fastcall */ #if CYTHON_METH_FASTCALL -static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) -{ +static CYTHON_INLINE PyObject *__Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) { Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); - for (i = 0; i < n; i++) - { + for (i = 0; i < n; i++) { if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; } - for (i = 0; i < n; i++) - { + for (i = 0; i < n; i++) { int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); if (unlikely(eq != 0)) { if (unlikely(eq < 0)) return NULL; @@ -5780,12 +6113,10 @@ CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, Py Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); PyObject *dict; dict = PyDict_New(); - if (unlikely(!dict)) - return NULL; - for (i=0; i= 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 +#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 *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, - PyObject *values[], - Py_ssize_t num_pos_args, - const char* function_name) -{ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, 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; + PyObject ***name; + PyObject ***first_kw_arg = argnames + num_pos_args; int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); while (1) { - Py_XDECREF(key); key = NULL; - Py_XDECREF(value); value = NULL; + Py_XDECREF(key); + key = NULL; + Py_XDECREF(value); + value = NULL; if (kwds_is_tuple) { Py_ssize_t size; #if CYTHON_ASSUME_SAFE_MACROS @@ -5847,9 +6170,7 @@ static int __Pyx_ParseOptionalKeywords( #endif value = kwvalues[pos]; pos++; - } - else - { + } else { if (!PyDict_Next(kwds, &pos, &key, &value)) break; #if CYTHON_AVOID_BORROWED_REFS Py_INCREF(key); @@ -5858,7 +6179,7 @@ static int __Pyx_ParseOptionalKeywords( name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { - values[name-argnames] = value; + values[name - argnames] = value; #if CYTHON_AVOID_BORROWED_REFS Py_INCREF(value); Py_DECREF(key); @@ -5872,12 +6193,12 @@ static int __Pyx_ParseOptionalKeywords( #endif Py_INCREF(value); name = first_kw_arg; - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(PyString_Check(key))) { while (*name) { - if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) - && _PyString_Eq(**name, key)) { - values[name-argnames] = value; + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && + _PyString_Eq(**name, key)) { + values[name - argnames] = value; #if CYTHON_AVOID_BORROWED_REFS value = NULL; #endif @@ -5885,31 +6206,32 @@ static int __Pyx_ParseOptionalKeywords( } name++; } - if (*name) continue; + if (*name) + continue; else { - PyObject*** argname = argnames; + 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))) { + 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))) { +#endif + if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = ( - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 +#if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**name, key) - ); +#endif + PyUnicode_Compare(**name, + key)); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { - values[name-argnames] = value; + values[name - argnames] = value; #if CYTHON_AVOID_BORROWED_REFS value = NULL; #endif @@ -5917,15 +6239,18 @@ static int __Pyx_ParseOptionalKeywords( } name++; } - if (*name) continue; + if (*name) + continue; else { - PyObject*** argname = argnames; + PyObject ***argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**argname, key); +#if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) + ? 1 + : +#endif + PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; @@ -5946,19 +6271,15 @@ static int __Pyx_ParseOptionalKeywords( __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); + PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: - #if PY_MAJOR_VERSION < 3 - PyErr_Format(PyExc_TypeError, - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - PyErr_Format(PyExc_TypeError, - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif +#if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, "%.200s() got an unexpected keyword argument '%.200s'", function_name, + PyString_AsString(key)); +#else + PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); +#endif bad: Py_XDECREF(key); Py_XDECREF(value); @@ -5966,13 +6287,8 @@ static int __Pyx_ParseOptionalKeywords( } /* 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) -{ +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) { @@ -5986,9 +6302,9 @@ static void __Pyx_RaiseArgtupleInvalid( 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); + "%.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); } /* Import */ @@ -5996,56 +6312,49 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *module = 0; PyObject *empty_dict = 0; PyObject *empty_list = 0; - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); - if (unlikely(!py_import)) - goto bad; + if (unlikely(!py_import)) goto bad; if (!from_list) { empty_list = PyList_New(0); - if (unlikely(!empty_list)) - goto bad; + if (unlikely(!empty_list)) goto bad; from_list = empty_list; } - #endif +#endif empty_dict = PyDict_New(); - if (unlikely(!empty_dict)) - goto bad; + if (unlikely(!empty_dict)) goto bad; { - #if PY_MAJOR_VERSION >= 3 +#if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { - module = PyImport_ImportModuleLevelObject( - name, __pyx_d, empty_dict, from_list, 1); + module = PyImport_ImportModuleLevelObject(name, __pyx_d, empty_dict, from_list, 1); if (unlikely(!module)) { - if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) - goto bad; + if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) goto bad; PyErr_Clear(); } } level = 0; } - #endif +#endif if (!module) { - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); - if (unlikely(!py_level)) - goto bad; - module = PyObject_CallFunctionObjArgs(py_import, - name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); + if (unlikely(!py_level)) goto bad; + module = PyObject_CallFunctionObjArgs(py_import, name, __pyx_d, empty_dict, from_list, py_level, + (PyObject *)NULL); Py_DECREF(py_level); - #else - module = PyImport_ImportModuleLevelObject( - name, __pyx_d, empty_dict, from_list, level); - #endif +#else + module = PyImport_ImportModuleLevelObject(name, __pyx_d, empty_dict, from_list, level); +#endif } } bad: Py_XDECREF(empty_dict); Py_XDECREF(empty_list); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); - #endif +#endif return module; } @@ -6060,17 +6369,14 @@ static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts partial_name = name; } else { slice = PySequence_GetSlice(parts_tuple, 0, count); - if (unlikely(!slice)) - goto bad; + if (unlikely(!slice)) goto bad; sep = PyUnicode_FromStringAndSize(".", 1); - if (unlikely(!sep)) - goto bad; + if (unlikely(!sep)) goto bad; partial_name = PyUnicode_Join(sep, slice); } PyErr_Format( #if PY_MAJOR_VERSION < 3 - PyExc_ImportError, - "No module named '%s'", PyString_AS_STRING(partial_name)); + PyExc_ImportError, "No module named '%s'", PyString_AS_STRING(partial_name)); #else #if PY_VERSION_HEX >= 0x030600B1 PyExc_ModuleNotFoundError, @@ -6089,10 +6395,9 @@ static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts #if PY_MAJOR_VERSION >= 3 static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { PyObject *imported_module; -#if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) +#if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) PyObject *modules = PyImport_GetModuleDict(); - if (unlikely(!modules)) - return NULL; + if (unlikely(!modules)) return NULL; imported_module = __Pyx_PyDict_GetItemStr(modules, name); Py_XINCREF(imported_module); #else @@ -6105,7 +6410,7 @@ static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { Py_ssize_t i, nparts; nparts = PyTuple_GET_SIZE(parts_tuple); - for (i=1; i < nparts && module; i++) { + for (i = 1; i < nparts && module; i++) { PyObject *part, *submodule; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS part = PyTuple_GET_ITEM(parts_tuple, i); @@ -6130,8 +6435,7 @@ static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple PyObject *module, *from_list, *star = __pyx_n_s_; CYTHON_UNUSED_VAR(parts_tuple); from_list = PyList_New(1); - if (unlikely(!from_list)) - return NULL; + if (unlikely(!from_list)) return NULL; Py_INCREF(star); PyList_SET_ITEM(from_list, 0, star); module = __Pyx_Import(name, from_list, 0); @@ -6140,8 +6444,7 @@ static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple #else PyObject *imported_module; PyObject *module = __Pyx_Import(name, NULL, 0); - if (!parts_tuple || unlikely(!module)) - return module; + if (!parts_tuple || unlikely(!module)) return module; imported_module = __Pyx__ImportDottedModule_Lookup(name); if (likely(imported_module)) { Py_DECREF(module); @@ -6185,14 +6488,13 @@ static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject CYTHON_UNUSED_VAR(type); #else const PyType_Slot *slot = spec->slots; - while (slot && slot->slot && slot->slot != Py_tp_members) - slot++; + while (slot && slot->slot && slot->slot != Py_tp_members) slot++; if (slot && slot->slot == Py_tp_members) { int changed = 0; #if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) const #endif - PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + PyMemberDef *memb = (PyMemberDef *)slot->pfunc; while (memb && memb->name) { if (memb->name[0] == '_' && memb->name[1] == '_') { #if PY_VERSION_HEX < 0x030900b1 @@ -6201,8 +6503,7 @@ static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject assert(memb->flags == READONLY); type->tp_weaklistoffset = memb->offset; changed = 1; - } - else if (strcmp(memb->name, "__dictoffset__") == 0) { + } else if (strcmp(memb->name, "__dictoffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); type->tp_dictoffset = memb->offset; @@ -6215,13 +6516,14 @@ static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject #if PY_VERSION_HEX >= 0x030800b4 type->tp_vectorcall_offset = memb->offset; #else - type->tp_print = (printfunc) memb->offset; + type->tp_print = (printfunc)memb->offset; #endif changed = 1; } #endif #else - if ((0)); + if ((0)) + ; #endif #if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON else if (strcmp(memb->name, "__module__") == 0) { @@ -6229,8 +6531,7 @@ static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject assert(memb->type == T_OBJECT); assert(memb->flags == 0 || memb->flags == READONLY); descr = PyDescr_NewMember(type, memb); - if (unlikely(!descr)) - return -1; + if (unlikely(!descr)) return -1; if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { Py_DECREF(descr); return -1; @@ -6242,8 +6543,7 @@ static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject } memb++; } - if (changed) - PyType_Modified(type); + if (changed) PyType_Modified(type); } #endif return 0; @@ -6252,43 +6552,35 @@ static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject /* FetchSharedCythonModule */ static PyObject *__Pyx_FetchSharedCythonABIModule(void) { - return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); + return __Pyx_PyImport_AddModuleRef((char *)__PYX_ABI_MODULE_NAME); } /* FetchCommonType */ -static int __Pyx_VerifyCachedType(PyObject *cached_type, - const char *name, - Py_ssize_t basicsize, - Py_ssize_t expected_basicsize) { +static int __Pyx_VerifyCachedType(PyObject *cached_type, const char *name, Py_ssize_t basicsize, + Py_ssize_t expected_basicsize) { if (!PyType_Check(cached_type)) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s is not a type object", name); + PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s is not a type object", name); return -1; } if (basicsize != expected_basicsize) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s has the wrong size, try recompiling", - name); + PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s has the wrong size, try recompiling", name); return -1; } return 0; } #if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { - PyObject* abi_module; - const char* object_name; +static PyTypeObject *__Pyx_FetchCommonType(PyTypeObject *type) { + PyObject *abi_module; + const char *object_name; PyTypeObject *cached_type = NULL; abi_module = __Pyx_FetchSharedCythonABIModule(); if (!abi_module) return NULL; object_name = strrchr(type->tp_name, '.'); - object_name = object_name ? object_name+1 : type->tp_name; - cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); + object_name = object_name ? object_name + 1 : type->tp_name; + cached_type = (PyTypeObject *)PyObject_GetAttrString(abi_module, object_name); if (cached_type) { - if (__Pyx_VerifyCachedType( - (PyObject *)cached_type, - object_name, - cached_type->tp_basicsize, - type->tp_basicsize) < 0) { + if (__Pyx_VerifyCachedType((PyObject *)cached_type, object_name, cached_type->tp_basicsize, + type->tp_basicsize) < 0) { goto bad; } goto done; @@ -6296,8 +6588,7 @@ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; PyErr_Clear(); if (PyType_Ready(type) < 0) goto bad; - if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) - goto bad; + if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) goto bad; Py_INCREF(type); cached_type = type; done: @@ -6311,8 +6602,8 @@ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { #else static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { PyObject *abi_module, *cached_type = NULL; - const char* object_name = strrchr(spec->name, '.'); - object_name = object_name ? object_name+1 : spec->name; + const char *object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name + 1 : spec->name; abi_module = __Pyx_FetchSharedCythonABIModule(); if (!abi_module) return NULL; cached_type = PyObject_GetAttrString(abi_module, object_name); @@ -6327,13 +6618,9 @@ static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec py_basicsize = 0; if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; #else - basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; + basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject *)cached_type)->tp_basicsize : -1; #endif - if (__Pyx_VerifyCachedType( - cached_type, - object_name, - basicsize, - spec->basicsize) < 0) { + if (__Pyx_VerifyCachedType(cached_type, object_name, basicsize, spec->basicsize) < 0) { goto bad; } goto done; @@ -6343,12 +6630,12 @@ static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec CYTHON_UNUSED_VAR(module); cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); if (unlikely(!cached_type)) goto bad; - if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *)cached_type) < 0)) goto bad; if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; done: Py_DECREF(abi_module); assert(cached_type == NULL || PyType_Check(cached_type)); - return (PyTypeObject *) cached_type; + return (PyTypeObject *)cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; @@ -6358,8 +6645,8 @@ static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec /* PyVectorcallFastCallDict */ #if CYTHON_METH_FASTCALL -static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) -{ +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, + size_t nargs, PyObject *kw) { PyObject *res = NULL; PyObject *kwnames; PyObject **newargs; @@ -6398,13 +6685,12 @@ static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vector res = vc(func, newargs, nargs, kwnames); cleanup: Py_DECREF(kwnames); - for (i = 0; i < nkw; i++) - Py_DECREF(kwvalues[i]); + for (i = 0; i < nkw; i++) Py_DECREF(kwvalues[i]); PyMem_Free(newargs); return res; } -static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) -{ +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, + PyObject *const *args, size_t nargs, PyObject *kw) { if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { return vc(func, args, nargs, NULL); } @@ -6416,45 +6702,39 @@ static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, _ #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { if (__Pyx_CyFunction_Check(func)) { - return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + return PyCFunction_GetFunction(((__pyx_CyFunctionObject *)func)->func) == (PyCFunction)cfunc; } else if (PyCFunction_Check(func)) { - return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + return PyCFunction_GetFunction(func) == (PyCFunction)cfunc; } return 0; } #else static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { - return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction)cfunc; } #endif -static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject *f, PyObject *classobj) { #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - __Pyx_Py_XDECREF_SET( - __Pyx_CyFunction_GetClassObj(f), - ((classobj) ? __Pyx_NewRef(classobj) : NULL)); + __Pyx_Py_XDECREF_SET(__Pyx_CyFunction_GetClassObj(f), ((classobj) ? __Pyx_NewRef(classobj) : NULL)); #else - __Pyx_Py_XDECREF_SET( - ((PyCMethodObject *) (f))->mm_class, - (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); + __Pyx_Py_XDECREF_SET(((PyCMethodObject *)(f))->mm_class, + (PyTypeObject *)((classobj) ? __Pyx_NewRef(classobj) : NULL)); #endif } -static PyObject * -__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) -{ +static PyObject *__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { CYTHON_UNUSED_VAR(closure); if (unlikely(op->func_doc == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); if (unlikely(!op->func_doc)) return NULL; #else - if (((PyCFunctionObject*)op)->m_ml->ml_doc) { + if (((PyCFunctionObject *)op)->m_ml->ml_doc) { #if PY_MAJOR_VERSION >= 3 - op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); + op->func_doc = PyUnicode_FromString(((PyCFunctionObject *)op)->m_ml->ml_doc); #else - op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); + op->func_doc = PyString_FromString(((PyCFunctionObject *)op)->m_ml->ml_doc); #endif - if (unlikely(op->func_doc == NULL)) - return NULL; + if (unlikely(op->func_doc == NULL)) return NULL; } else { Py_INCREF(Py_None); return Py_None; @@ -6464,9 +6744,7 @@ __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) Py_INCREF(op->func_doc); return op->func_doc; } -static int -__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ +static int __Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); if (value == NULL) { value = Py_None; @@ -6475,27 +6753,22 @@ __Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *cont __Pyx_Py_XDECREF_SET(op->func_doc, value); return 0; } -static PyObject * -__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) -{ +static PyObject *__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(op->func_name == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API op->func_name = PyObject_GetAttrString(op->func, "__name__"); #elif PY_MAJOR_VERSION >= 3 - op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject *)op)->m_ml->ml_name); #else - op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); + op->func_name = PyString_InternFromString(((PyCFunctionObject *)op)->m_ml->ml_name); #endif - if (unlikely(op->func_name == NULL)) - return NULL; + 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, void *context) -{ +static int __Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) @@ -6503,24 +6776,19 @@ __Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *con if (unlikely(value == NULL || !PyString_Check(value))) #endif { - PyErr_SetString(PyExc_TypeError, - "__name__ must be set to a string object"); + PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_name, value); return 0; } -static PyObject * -__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) -{ +static PyObject *__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); Py_INCREF(op->func_qualname); return op->func_qualname; } -static int -__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ +static int __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) @@ -6528,108 +6796,92 @@ __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void if (unlikely(value == NULL || !PyString_Check(value))) #endif { - PyErr_SetString(PyExc_TypeError, - "__qualname__ must be set to a string object"); + PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_qualname, value); return 0; } -static PyObject * -__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) -{ +static PyObject *__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(op->func_dict == NULL)) { op->func_dict = PyDict_New(); - if (unlikely(op->func_dict == NULL)) - return NULL; + 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, void *context) -{ +static int __Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); if (unlikely(value == NULL)) { - PyErr_SetString(PyExc_TypeError, - "function's dictionary may not be deleted"); + 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"); + PyErr_SetString(PyExc_TypeError, "setting function's dictionary to a non-dict"); return -1; } Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->func_dict, value); return 0; } -static PyObject * -__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) -{ +static PyObject *__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); Py_INCREF(op->func_globals); return op->func_globals; } -static PyObject * -__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) -{ +static PyObject *__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(op); CYTHON_UNUSED_VAR(context); Py_INCREF(Py_None); return Py_None; } -static PyObject * -__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) -{ - PyObject* result = (op->func_code) ? op->func_code : Py_None; +static PyObject *__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) { + PyObject *result = (op->func_code) ? op->func_code : Py_None; CYTHON_UNUSED_VAR(context); Py_INCREF(result); return result; } -static int -__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { +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 + 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 +#else op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); - if (unlikely(!op->defaults_tuple)) result = -1; + if (unlikely(!op->defaults_tuple)) + result = -1; else { op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); if (unlikely(!op->defaults_kwdict)) result = -1; } - #endif +#endif Py_DECREF(res); return result; } -static int -__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { +static int __Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); if (!value) { value = Py_None; } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__defaults__ must be set to a tuple object"); + PyErr_SetString(PyExc_TypeError, "__defaults__ must be set to a tuple object"); return -1; } - PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " - "currently affect the values used in function calls", 1); + PyErr_WarnEx(PyExc_RuntimeWarning, + "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", + 1); Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); return 0; } -static PyObject * -__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->defaults_tuple; +static PyObject *__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject *result = op->defaults_tuple; CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { if (op->defaults_getter) { @@ -6642,25 +6894,24 @@ __Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { Py_INCREF(result); return result; } -static int -__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { +static int __Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); if (!value) { value = Py_None; } else if (unlikely(value != Py_None && !PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__kwdefaults__ must be set to a dict object"); + PyErr_SetString(PyExc_TypeError, "__kwdefaults__ must be set to a dict object"); return -1; } - PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " - "currently affect the values used in function calls", 1); + PyErr_WarnEx(PyExc_RuntimeWarning, + "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", + 1); Py_INCREF(value); __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); return 0; } -static PyObject * -__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->defaults_kwdict; +static PyObject *__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject *result = op->defaults_kwdict; CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { if (op->defaults_getter) { @@ -6673,23 +6924,20 @@ __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { Py_INCREF(result); return result; } -static int -__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { +static int __Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); if (!value || value == Py_None) { value = NULL; } else if (unlikely(!PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__annotations__ must be set to a dict object"); + PyErr_SetString(PyExc_TypeError, "__annotations__ must be set to a dict object"); return -1; } Py_XINCREF(value); __Pyx_Py_XDECREF_SET(op->func_annotations, value); return 0; } -static PyObject * -__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->func_annotations; +static PyObject *__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject *result = op->func_annotations; CYTHON_UNUSED_VAR(context); if (unlikely(!result)) { result = PyDict_New(); @@ -6699,8 +6947,7 @@ __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { Py_INCREF(result); return result; } -static PyObject * -__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { +static PyObject *__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { int is_coroutine; CYTHON_UNUSED_VAR(context); if (op->func_is_coroutine) { @@ -6730,7 +6977,7 @@ __Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { if (likely(op->func_is_coroutine)) { return __Pyx_NewRef(op->func_is_coroutine); } -ignore: + ignore: PyErr_Clear(); } #endif @@ -6738,100 +6985,92 @@ __Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { return __Pyx_NewRef(op->func_is_coroutine); } #if CYTHON_COMPILING_IN_LIMITED_API -static PyObject * -__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { +static PyObject *__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); return PyObject_GetAttrString(op->func, "__module__"); } -static int -__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { +static int __Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject *value, void *context) { CYTHON_UNUSED_VAR(context); return PyObject_SetAttrString(op->func, "__module__", value); } #endif 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 *) "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}, - {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, + {(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 *)"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}, + {(char *)"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, #if CYTHON_COMPILING_IN_LIMITED_API {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, #endif - {0, 0, 0, 0, 0} -}; + {0, 0, 0, 0, 0}}; static PyMemberDef __pyx_CyFunction_members[] = { #if !CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, + {(char *)"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, #endif #if CYTHON_USE_TYPE_SPECS - {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, + {(char *)"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, #if CYTHON_METH_FASTCALL #if CYTHON_BACKPORT_VECTORCALL - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, + {(char *)"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, #else #if !CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, + {(char *)"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, #endif #endif #endif #if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, + {(char *)"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, #else - {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, + {(char *)"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, #endif #endif - {0, 0, 0, 0, 0} -}; -static PyObject * -__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) -{ + {0, 0, 0, 0, 0}}; +static PyObject *__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) { CYTHON_UNUSED_VAR(args); #if PY_MAJOR_VERSION >= 3 Py_INCREF(m->func_qualname); return m->func_qualname; #else - return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); + return PyString_FromString(((PyCFunctionObject *)m)->m_ml->ml_name); #endif } -static PyMethodDef __pyx_CyFunction_methods[] = { - {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, - {0, 0, 0, 0} -}; +static PyMethodDef __pyx_CyFunction_methods[] = {{"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0}}; #if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) #else -#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject *)cyfunc)->m_weakreflist) #endif -static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, - PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject *qualname, + PyObject *closure, PyObject *module, PyObject *globals, PyObject *code) { #if !CYTHON_COMPILING_IN_LIMITED_API - PyCFunctionObject *cf = (PyCFunctionObject*) op; + PyCFunctionObject *cf = (PyCFunctionObject *)op; #endif - if (unlikely(op == NULL)) - return NULL; + if (unlikely(op == NULL)) return NULL; #if CYTHON_COMPILING_IN_LIMITED_API - op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + op->func = PyCFunction_NewEx(ml, (PyObject *)op, module); if (unlikely(!op->func)) return NULL; #endif op->flags = flags; __Pyx_CyFunction_weakreflist(op) = NULL; #if !CYTHON_COMPILING_IN_LIMITED_API cf->m_ml = ml; - cf->m_self = (PyObject *) op; + cf->m_self = (PyObject *)op; #endif Py_XINCREF(closure); op->func_closure = closure; @@ -6847,7 +7086,7 @@ static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef * #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API op->func_classobj = NULL; #else - ((PyCMethodObject*)op)->mm_class = NULL; + ((PyCMethodObject *)op)->mm_class = NULL; #endif op->func_globals = globals; Py_INCREF(op->func_globals); @@ -6863,37 +7102,35 @@ static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef * op->func_is_coroutine = NULL; #if CYTHON_METH_FASTCALL switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { - case METH_NOARGS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; - break; - case METH_O: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; - break; - case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; - break; - case METH_FASTCALL | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; - break; - case METH_VARARGS | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = NULL; - break; - default: - PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); - Py_DECREF(op); - return NULL; + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; } #endif - return (PyObject *) op; + return (PyObject *)op; } -static int -__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) -{ +static int __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) { Py_CLEAR(m->func_closure); #if CYTHON_COMPILING_IN_LIMITED_API Py_CLEAR(m->func); #else - Py_CLEAR(((PyCFunctionObject*)m)->m_module); + Py_CLEAR(((PyCFunctionObject *)m)->m_module); #endif Py_CLEAR(m->func_dict); Py_CLEAR(m->func_name); @@ -6906,8 +7143,8 @@ __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); #else { - PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; - ((PyCMethodObject *) (m))->mm_class = NULL; + PyObject *cls = (PyObject *)((PyCMethodObject *)(m))->mm_class; + ((PyCMethodObject *)(m))->mm_class = NULL; Py_XDECREF(cls); } #endif @@ -6919,32 +7156,27 @@ __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) if (m->defaults) { PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_XDECREF(pydefaults[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); +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) { + if (__Pyx_CyFunction_weakreflist(m) != NULL) PyObject_ClearWeakRefs((PyObject *)m); __Pyx_CyFunction_clear(m); __Pyx_PyHeapTypeObject_GC_Del(m); } -static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *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) -{ +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) { Py_VISIT(m->func_closure); #if CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(m->func); #else - Py_VISIT(((PyCFunctionObject*)m)->m_module); + Py_VISIT(((PyCFunctionObject *)m)->m_module); #endif Py_VISIT(m->func_dict); Py_VISIT(m->func_name); @@ -6961,25 +7193,20 @@ static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, if (m->defaults) { PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_VISIT(pydefaults[i]); + for (i = 0; i < m->defaults_pyobjects; i++) Py_VISIT(pydefaults[i]); } return 0; } -static PyObject* -__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) -{ +static PyObject *__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) { #if PY_MAJOR_VERSION >= 3 - return PyUnicode_FromFormat("", - op->func_qualname, (void *)op); + return PyUnicode_FromFormat("", op->func_qualname, (void *)op); #else - return PyString_FromFormat("", - PyString_AsString(op->func_qualname), (void *)op); + return PyString_FromFormat("", PyString_AsString(op->func_qualname), (void *)op); #endif } -static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +static PyObject *__Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { #if CYTHON_COMPILING_IN_LIMITED_API - PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyObject *f = ((__pyx_CyFunctionObject *)func)->func; PyObject *py_name = NULL; PyCFunction meth; int flags; @@ -6988,116 +7215,110 @@ static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, Py flags = PyCFunction_GetFlags(f); if (unlikely(flags < 0)) return NULL; #else - PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunctionObject *f = (PyCFunctionObject *)func; PyCFunction meth = f->m_ml->ml_meth; int flags = f->m_ml->ml_flags; #endif Py_ssize_t size; switch (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)) { + 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)) { #if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(arg); + size = PyTuple_GET_SIZE(arg); #else - size = PyTuple_Size(arg); - if (unlikely(size < 0)) return NULL; + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; #endif - if (likely(size == 0)) - return (*meth)(self, NULL); + if (likely(size == 0)) return (*meth)(self, NULL); #if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject *)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); #else - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); + PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); #endif - return NULL; - } - break; - case METH_O: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) { -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(arg); -#else - size = PyTuple_Size(arg); - if (unlikely(size < 0)) return NULL; -#endif - if (likely(size == 1)) { - PyObject *result, *arg0; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - arg0 = PyTuple_GET_ITEM(arg, 0); - #else - arg0 = __Pyx_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; + return NULL; } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); +#else + arg0 = __Pyx_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; + } #if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject *)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); #else - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); + PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); #endif + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); return NULL; - } - break; - default: - PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); - return NULL; } #if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject *)func, NULL); if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", - py_name); + PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", py_name); Py_DECREF(py_name); #else - PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", - f->m_ml->ml_name); + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", f->m_ml->ml_name); #endif return NULL; } static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *self, *result; #if CYTHON_COMPILING_IN_LIMITED_API - self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject *)func)->func); if (unlikely(!self) && PyErr_Occurred()) return NULL; #else - self = ((PyCFunctionObject*)func)->m_self; + self = ((PyCFunctionObject *)func)->m_self; #endif result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); return result; } static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { PyObject *result; - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; #if CYTHON_METH_FASTCALL - __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); if (vc) { #if CYTHON_ASSUME_SAFE_MACROS - return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), + kw); #else - (void) &__Pyx_PyVectorcall_FastCallDict; + (void)&__Pyx_PyVectorcall_FastCallDict; return PyVectorcall_Call(func, args, kw); #endif } @@ -7113,18 +7334,14 @@ static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, P if (unlikely(!argc) < 0) return NULL; #endif new_args = PyTuple_GetSlice(args, 1, argc); - if (unlikely(!new_args)) - return NULL; + if (unlikely(!new_args)) return NULL; self = PyTuple_GetItem(args, 0); if (unlikely(!self)) { Py_DECREF(new_args); #if PY_MAJOR_VERSION > 2 - PyErr_Format(PyExc_TypeError, - "unbound method %.200S() needs an argument", - cyfunc->func_qualname); + PyErr_Format(PyExc_TypeError, "unbound method %.200S() needs an argument", cyfunc->func_qualname); #else - PyErr_SetString(PyExc_TypeError, - "unbound method needs an argument"); + PyErr_SetString(PyExc_TypeError, "unbound method needs an argument"); #endif return NULL; } @@ -7136,28 +7353,27 @@ static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, P return result; } #if CYTHON_METH_FASTCALL -static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) -{ +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, + PyObject *kwnames) { int ret = 0; if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { if (unlikely(nargs < 1)) { - PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", - ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", ((PyCFunctionObject *)cyfunc)->m_ml->ml_name); return -1; } ret = 1; } if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + ((PyCFunctionObject *)cyfunc)->m_ml->ml_name); return -1; } return ret; } -static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ +static PyObject *__Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, + PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + PyMethodDef *def = ((PyCFunctionObject *)cyfunc)->m_ml; #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else @@ -7165,29 +7381,28 @@ static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *c #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject *)cyfunc)->m_self; + break; + default: + return NULL; } if (unlikely(nargs != 0)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); + PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", def->ml_name, + nargs); return NULL; } return def->ml_meth(self, NULL); } -static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ +static PyObject *__Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, + PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + PyMethodDef *def = ((PyCFunctionObject *)cyfunc)->m_ml; #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else @@ -7195,29 +7410,28 @@ static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject *)cyfunc)->m_self; + break; + default: + return NULL; } if (unlikely(nargs != 1)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); + PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); return NULL; } return def->ml_meth(self, args[0]); } -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ +static PyObject *__Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, + PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + PyMethodDef *def = ((PyCFunctionObject *)cyfunc)->m_ml; #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else @@ -7225,24 +7439,24 @@ static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject *)cyfunc)->m_self; + break; + default: + return NULL; } - return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); + return ((__Pyx_PyCFunctionFastWithKeywords)(void (*)(void))def->ml_meth)(self, args, nargs, kwnames); } -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ +static PyObject *__Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, + size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; - PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); + PyMethodDef *def = ((PyCFunctionObject *)cyfunc)->m_ml; + PyTypeObject *cls = (PyTypeObject *)__Pyx_CyFunction_GetClassObj(cyfunc); #if CYTHON_BACKPORT_VECTORCALL Py_ssize_t nargs = (Py_ssize_t)nargsf; #else @@ -7250,53 +7464,44 @@ static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject #endif PyObject *self; switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject *)cyfunc)->m_self; + break; + default: + return NULL; } - return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); + return ((__Pyx_PyCMethod)(void (*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); } #endif #if CYTHON_USE_TYPE_SPECS static PyType_Slot __pyx_CyFunctionType_slots[] = { - {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, - {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, - {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, - {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, - {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, - {Py_tp_methods, (void *)__pyx_CyFunction_methods}, - {Py_tp_members, (void *)__pyx_CyFunction_members}, - {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, - {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, - {0, 0}, + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, {0, 0}, }; -static PyType_Spec __pyx_CyFunctionType_spec = { - __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", - sizeof(__pyx_CyFunctionObject), - 0, +static PyType_Spec __pyx_CyFunctionType_spec = {__PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), 0, #ifdef Py_TPFLAGS_METHOD_DESCRIPTOR - Py_TPFLAGS_METHOD_DESCRIPTOR | + Py_TPFLAGS_METHOD_DESCRIPTOR | #endif #if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) - _Py_TPFLAGS_HAVE_VECTORCALL | + _Py_TPFLAGS_HAVE_VECTORCALL | #endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, - __pyx_CyFunctionType_slots -}; + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots}; #else static PyTypeObject __pyx_CyFunctionType_type = { - PyVarObject_HEAD_INIT(0, 0) - __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + PyVarObject_HEAD_INIT(0, 0) __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", sizeof(__pyx_CyFunctionObject), 0, - (destructor) __Pyx_CyFunction_dealloc, + (destructor)__Pyx_CyFunction_dealloc, #if !CYTHON_METH_FASTCALL 0, #elif CYTHON_BACKPORT_VECTORCALL @@ -7311,7 +7516,7 @@ static PyTypeObject __pyx_CyFunctionType_type = { #else 0, #endif - (reprfunc) __Pyx_CyFunction_repr, + (reprfunc)__Pyx_CyFunction_repr, 0, 0, 0, @@ -7325,12 +7530,12 @@ static PyTypeObject __pyx_CyFunctionType_type = { Py_TPFLAGS_METHOD_DESCRIPTOR | #endif #if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL - _Py_TPFLAGS_HAVE_VECTORCALL | + _Py_TPFLAGS_HAVE_VECTORCALL | #endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, 0, - (traverseproc) __Pyx_CyFunction_traverse, - (inquiry) __Pyx_CyFunction_clear, + (traverseproc)__Pyx_CyFunction_traverse, + (inquiry)__Pyx_CyFunction_clear, 0, #if PY_VERSION_HEX < 0x030500A0 offsetof(__pyx_CyFunctionObject, func_weakreflist), @@ -7389,38 +7594,35 @@ static int __pyx_CyFunction_init(PyObject *module) { return 0; } static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *)func; m->defaults = PyObject_Malloc(size); - if (unlikely(!m->defaults)) - return PyErr_NoMemory(); + if (unlikely(!m->defaults)) return PyErr_NoMemory(); memset(m->defaults, 0, size); m->defaults_pyobjects = pyobjects; m->defaults_size = size; return m->defaults; } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + __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; + __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; + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *)func; m->func_annotations = dict; Py_INCREF(dict); } /* CythonFunction */ -static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, - PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { - PyObject *op = __Pyx_CyFunction_Init( - PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), - ml, flags, qualname, closure, module, globals, code - ); +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject *qualname, PyObject *closure, + PyObject *module, PyObject *globals, PyObject *code) { + PyObject *op = __Pyx_CyFunction_Init(PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), ml, flags, + qualname, closure, module, globals, code); if (likely(op)) { PyObject_GC_Track(op); } @@ -7443,26 +7645,24 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { #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)) + __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_GetAttrStrNoError(__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; - } + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } } if (!use_cline) { c_line = 0; - (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); - } - else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + (void)PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); @@ -7472,7 +7672,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { /* CodeObjectCache */ #if !CYTHON_COMPILING_IN_LIMITED_API -static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { +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; @@ -7482,7 +7682,7 @@ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int co if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { - start = mid + 1; + start = mid + 1; } else { return mid; } @@ -7494,7 +7694,7 @@ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int co } } static PyCodeObject *__pyx_find_code_object(int code_line) { - PyCodeObject* code_object; + PyCodeObject *code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; @@ -7507,14 +7707,14 @@ static PyCodeObject *__pyx_find_code_object(int code_line) { Py_INCREF(code_object); return code_object; } -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { +static void __pyx_insert_code_object(int code_line, PyCodeObject *code_object) { int pos, i; - __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + __Pyx_CodeObjectCacheEntry *entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { - entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + entries = (__Pyx_CodeObjectCacheEntry *)PyMem_Malloc(64 * sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; @@ -7527,23 +7727,23 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { } 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; + 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)); + 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]; + 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; @@ -7557,14 +7757,14 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { #include "frameobject.h" #include "traceback.h" #if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #ifndef Py_BUILD_CORE - #define Py_BUILD_CORE 1 - #endif - #include "internal/pycore_frame.h" +#ifndef Py_BUILD_CORE +#define Py_BUILD_CORE 1 +#endif +#include "internal/pycore_frame.h" #endif #if CYTHON_COMPILING_IN_LIMITED_API -static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, - PyObject *firstlineno, PyObject *name) { +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, PyObject *firstlineno, + PyObject *name) { PyObject *replace = NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; @@ -7576,17 +7776,18 @@ static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject return result; } PyErr_Clear(); - #if __PYX_LIMITED_VERSION_HEX < 0x030780000 +#if __PYX_LIMITED_VERSION_HEX < 0x030780000 { PyObject *compiled = NULL, *result = NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject *)(&PyType_Type)))) return NULL; compiled = Py_CompileString( "out = type(code)(\n" " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" - " code.co_lnotab)\n", "", Py_file_input); + " code.co_lnotab)\n", + "", Py_file_input); if (!compiled) return NULL; result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); Py_DECREF(compiled); @@ -7596,19 +7797,18 @@ static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject if (result) Py_INCREF(result); return result; } - #else +#else return NULL; - #endif +#endif } -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename) { +static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; PyObject *replace = NULL, *getframe = NULL, *frame = NULL; PyObject *exc_type, *exc_value, *exc_traceback; int success = 0; if (c_line) { - (void) __pyx_cfilenm; - (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + (void)__pyx_cfilenm; + (void)__Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); } PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); code_object = Py_CompileString("_getframe()", filename, Py_eval_input); @@ -7631,7 +7831,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, frame = PyEval_EvalCode(code_object, dict, dict); if (unlikely(!frame) || frame == Py_None) goto bad; success = 1; - bad: +bad: PyErr_Restore(exc_type, exc_value, exc_traceback); Py_XDECREF(code_object); Py_XDECREF(py_py_line); @@ -7639,73 +7839,61 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(dict); Py_XDECREF(replace); if (success) { - PyTraceBack_Here( - (struct _frame*)frame); + PyTraceBack_Here((struct _frame *)frame); } Py_XDECREF(frame); } #else -static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( - const char *funcname, int c_line, - int py_line, const char *filename) { +static PyCodeObject *__Pyx_CreateCodeObjectForTraceback(const char *funcname, int c_line, int py_line, + const char *filename) { PyCodeObject *py_code = NULL; PyObject *py_funcname = NULL; - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 PyObject *py_srcfile = NULL; py_srcfile = PyString_FromString(filename); if (!py_srcfile) goto bad; - #endif +#endif if (c_line) { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); +#if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat("%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; - #else - py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); +#else + py_funcname = PyUnicode_FromFormat("%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; funcname = PyUnicode_AsUTF8(py_funcname); if (!funcname) goto bad; - #endif - } - else { - #if PY_MAJOR_VERSION < 3 +#endif + } else { +#if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); if (!py_funcname) goto bad; - #endif - } - #if PY_MAJOR_VERSION < 3 - py_code = __Pyx_PyCode_New( - 0, - 0, - 0, - 0, - 0, - 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*/ +#endif + } +#if PY_MAJOR_VERSION < 3 + py_code = __Pyx_PyCode_New(0, 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); - #else +#else py_code = PyCode_NewEmpty(filename, funcname, py_line); - #endif +#endif Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 Py_XDECREF(py_srcfile); - #endif +#endif return NULL; } -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename) { +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; @@ -7716,8 +7904,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); - py_code = __Pyx_CreateCodeObjectForTraceback( - funcname, c_line, py_line, filename); + py_code = __Pyx_CreateCodeObjectForTraceback(funcname, c_line, py_line, filename); if (!py_code) { /* If the code object creation fails, then we should clear the fetched exception references and propagate the new exception */ @@ -7729,11 +7916,10 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } - py_frame = PyFrame_New( - tstate, /*PyThreadState *tstate,*/ - py_code, /*PyCodeObject *code,*/ - __pyx_d, /*PyObject *globals,*/ - 0 /*PyObject *locals*/ + 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); @@ -7745,69 +7931,68 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, #endif /* CIntFromPyVerify */ -#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ +#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)\ +#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;\ +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc) \ + { \ + func_type value = func_value; \ + if (sizeof(target_type) < sizeof(func_type)) { \ + if (unlikely(value != (func_type)(target_type)value)) { \ + func_type zero = 0; \ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred())) return (target_type)-1; \ + if (is_unsigned && unlikely(value < zero)) \ + goto raise_neg_overflow; \ + else \ + goto raise_overflow; \ + } \ + } \ + return (target_type)value; \ } /* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { +static CYTHON_INLINE PyObject *__Pyx_PyInt_From_int(int value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif - const int neg_one = (int) -1, const_zero = (int) 0; + const int neg_one = (int)-1, const_zero = (int)0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { - return PyInt_FromLong((long) value); + return PyInt_FromLong((long)value); } else if (sizeof(int) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); + return PyLong_FromUnsignedLong((unsigned long)value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)value); #endif } } else { if (sizeof(int) <= sizeof(long)) { - return PyInt_FromLong((long) value); + return PyInt_FromLong((long)value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); + return PyLong_FromLongLong((PY_LONG_LONG)value); #endif } } { - int one = 1; int little = (int)*(unsigned char *)&one; + int one = 1; + int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(int), - little, !is_unsigned); + return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); #else PyObject *from_bytes, *result = NULL; PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; - from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + from_bytes = PyObject_GetAttrString((PyObject *)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; - py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + py_bytes = PyBytes_FromStringAndSize((char *)bytes, sizeof(int)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; @@ -7819,7 +8004,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; } result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: + limited_bad: Py_XDECREF(kwds); Py_XDECREF(arg_tuple); Py_XDECREF(order_str); @@ -7836,7 +8021,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif - const int neg_one = (int) -1, const_zero = (int) 0; + const int neg_one = (int)-1, const_zero = (int)0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif @@ -7850,11 +8035,11 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } - return (int) val; + return (int)val; } } else #endif - if (likely(PyLong_Check(x))) { + if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS if (unlikely(__Pyx_PyLong_IsNeg(x))) { @@ -7862,33 +8047,50 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { - const digit* digits = __Pyx_PyLong_Digits(x); + const digit *digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { 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]))) + __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])); + 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]))) + __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])); + 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]))) + __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])); + return ( + int)(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | + (int)digits[1]) + << PyLong_SHIFT) | + (int)digits[0])); } } break; @@ -7902,10 +8104,8 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #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; + if (unlikely(result < 0)) return (int)-1; + if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if ((sizeof(int) <= sizeof(unsigned long))) { @@ -7920,60 +8120,97 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { - const digit* digits = __Pyx_PyLong_Digits(x); + const digit *digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { 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]))) + __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]))); + 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]))) + __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]))); + 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]))) + __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]))); + 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]))) + __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]))); + 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]))) + __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]))); + 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]))) + __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]))); + return ( + int)((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | + (int)digits[1]) + << PyLong_SHIFT) | + (int)digits[0]))); } } break; @@ -8000,12 +8237,12 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #endif if (likely(v)) { int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || \ + defined(_PyLong_AsByteArray) + int one = 1; + int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; @@ -8016,17 +8253,15 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); - if (unlikely(!v)) return (int) -1; + if (unlikely(!v)) return (int)-1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (int) 0; + if (Py_SIZE(x) == 0) return (int)0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (int) -1; + if (unlikely(result < 0)) return (int)-1; is_negative = result == 1; } #endif @@ -8034,15 +8269,16 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { goto raise_neg_overflow; } else if (is_negative) { stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (int) -1; + if (unlikely(!stepval)) return (int)-1; } else { stepval = __Pyx_NewRef(v); } - val = (int) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + val = (int)0; + mask = PyLong_FromLong((1L << chunk_size) - 1); + if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); + if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int)sizeof(int) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; @@ -8051,27 +8287,24 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { if (unlikely(idigit < 0)) goto done; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif + Py_DECREF(stepval); + stepval = tmp; + val |= ((int)idigit) << bits; +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) goto unpacking_done; +#endif } idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + remaining_bits = ((int)sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; + val |= ((int)idigit) << bits; +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: - #endif +#endif if (!is_unsigned) { - if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; + if (unlikely(val & (((int)1) << (sizeof(int) * 8 - 1)))) goto raise_overflow; + if (is_negative) val = ~val; } ret = 0; done: @@ -8080,71 +8313,68 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { Py_XDECREF(stepval); #endif Py_DECREF(v); - if (likely(!ret)) - return val; + if (likely(!ret)) return val; } - return (int) -1; + return (int)-1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (int) -1; + 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; + 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; + PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); + return (int)-1; } /* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { +static CYTHON_INLINE PyObject *__Pyx_PyInt_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif - const long neg_one = (long) -1, const_zero = (long) 0; + const long neg_one = (long)-1, const_zero = (long)0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { - return PyInt_FromLong((long) value); + return PyInt_FromLong((long)value); } else if (sizeof(long) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); + 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); + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)value); #endif } } else { if (sizeof(long) <= sizeof(long)) { - return PyInt_FromLong((long) value); + return PyInt_FromLong((long)value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); + return PyLong_FromLongLong((PY_LONG_LONG)value); #endif } } { - int one = 1; int little = (int)*(unsigned char *)&one; + int one = 1; + int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(long), - little, !is_unsigned); + return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); #else PyObject *from_bytes, *result = NULL; PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; - from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + from_bytes = PyObject_GetAttrString((PyObject *)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; - py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + py_bytes = PyBytes_FromStringAndSize((char *)bytes, sizeof(long)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; @@ -8156,7 +8386,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; } result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: + limited_bad: Py_XDECREF(kwds); Py_XDECREF(arg_tuple); Py_XDECREF(order_str); @@ -8169,11 +8399,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { /* FormatTypeName */ #if CYTHON_COMPILING_IN_LIMITED_API -static __Pyx_TypeName -__Pyx_PyType_GetName(PyTypeObject* tp) -{ - PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, - __pyx_n_s_name); +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject *tp) { + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, __pyx_n_s_name); if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { PyErr_Clear(); Py_XDECREF(name); @@ -8189,7 +8416,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif - const long neg_one = (long) -1, const_zero = (long) 0; + const long neg_one = (long)-1, const_zero = (long)0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif @@ -8203,11 +8430,11 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } - return (long) val; + return (long)val; } } else #endif - if (likely(PyLong_Check(x))) { + if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS if (unlikely(__Pyx_PyLong_IsNeg(x))) { @@ -8215,33 +8442,51 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { } else if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) } else { - const digit* digits = __Pyx_PyLong_Digits(x); + const digit *digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_DigitCount(x)) { 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]))) + __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])); + 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]))) + __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])); + 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]))) + __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])); + return ( + long)(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | + (long)digits[1]) + << PyLong_SHIFT) | + (long)digits[0])); } } break; @@ -8255,10 +8500,8 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #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; + if (unlikely(result < 0)) return (long)-1; + if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if ((sizeof(long) <= sizeof(unsigned long))) { @@ -8273,60 +8516,97 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { if (__Pyx_PyLong_IsCompact(x)) { __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) } else { - const digit* digits = __Pyx_PyLong_Digits(x); + const digit *digits = __Pyx_PyLong_Digits(x); assert(__Pyx_PyLong_DigitCount(x) > 1); switch (__Pyx_PyLong_SignedDigitCount(x)) { 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]))) + __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]))); + 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]))) + __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]))); + 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]))) + __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]))); + 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]))) + __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]))); + 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]))) + __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]))); + 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]))) + __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]))); + return (long)(( + ((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | + (long)digits[1]) + << PyLong_SHIFT) | + (long)digits[0]))); } } break; @@ -8353,12 +8633,12 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #endif if (likely(v)) { int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || \ + defined(_PyLong_AsByteArray) + int one = 1; + int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); + ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); #else PyObject *stepval = NULL, *mask = NULL, *shift = NULL; int bits, remaining_bits, is_negative = 0; @@ -8369,17 +8649,15 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { v = PyNumber_Long(v); assert(PyLong_CheckExact(v)); Py_DECREF(tmp); - if (unlikely(!v)) return (long) -1; + if (unlikely(!v)) return (long)-1; } #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (long) 0; + if (Py_SIZE(x) == 0) return (long)0; is_negative = Py_SIZE(x) < 0; #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (long) -1; + if (unlikely(result < 0)) return (long)-1; is_negative = result == 1; } #endif @@ -8387,15 +8665,16 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { goto raise_neg_overflow; } else if (is_negative) { stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (long) -1; + if (unlikely(!stepval)) return (long)-1; } else { stepval = __Pyx_NewRef(v); } - val = (long) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + val = (long)0; + mask = PyLong_FromLong((1L << chunk_size) - 1); + if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); + if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int)sizeof(long) * 8 - chunk_size; bits += chunk_size) { PyObject *tmp, *digit; digit = PyNumber_And(stepval, mask); if (unlikely(!digit)) goto done; @@ -8404,27 +8683,24 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { if (unlikely(idigit < 0)) goto done; tmp = PyNumber_Rshift(stepval, shift); if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((long) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif + Py_DECREF(stepval); + stepval = tmp; + val |= ((long)idigit) << bits; +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) goto unpacking_done; +#endif } idigit = PyLong_AsLong(stepval); if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((long) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + remaining_bits = ((int)sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) goto raise_overflow; + val |= ((long)idigit) << bits; +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 unpacking_done: - #endif +#endif if (!is_unsigned) { - if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; + if (unlikely(val & (((long)1) << (sizeof(long) * 8 - 1)))) goto raise_overflow; + if (is_negative) val = ~val; } ret = 0; done: @@ -8433,36 +8709,32 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { Py_XDECREF(stepval); #endif Py_DECREF(v); - if (likely(!ret)) - return val; + if (likely(!ret)) return val; } - return (long) -1; + return (long)-1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (long) -1; + 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; + 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; + PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); + return (long)-1; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { - a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); - if (a == b) - return 1; + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject *); + if (a == b) return 1; } return b == &PyBaseObject_Type; } @@ -8474,8 +8746,7 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { 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; + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } @@ -8490,20 +8761,17 @@ static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { PyObject *base = PyTuple_GET_ITEM(mro, i); - if (base == (PyObject *)a || base == (PyObject *)b) - return 1; + if (base == (PyObject *)a || base == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); } #if PY_MAJOR_VERSION == 2 -static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { +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); + __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); @@ -8520,11 +8788,12 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc return res; } #else -static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, + PyObject *exc_type2) { if (exc_type1) { - return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + return __Pyx_IsAnySubtype2((PyTypeObject *)err, (PyTypeObject *)exc_type1, (PyTypeObject *)exc_type2); } else { - return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + return __Pyx_IsSubtype((PyTypeObject *)err, (PyTypeObject *)exc_type2); } } #endif @@ -8533,15 +8802,15 @@ static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject * assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 - for (i=0; i= 0x030B00A4 return Py_Version & ~0xFFUL; #else - const char* rt_version = Py_GetVersion(); + const char *rt_version = Py_GetVersion(); unsigned long version = 0; unsigned long factor = 0x01000000UL; unsigned int digit = 0; int i = 0; while (factor) { while ('0' <= rt_version[i] && rt_version[i] <= '9') { - digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + digit = digit * 10 + (unsigned int)(rt_version[i] - '0'); ++i; } version += factor * digit; - if (rt_version[i] != '.') - break; + if (rt_version[i] != '.') break; digit = 0; factor >>= 8; ++i; @@ -8599,10 +8867,8 @@ static unsigned long __Pyx_get_runtime_version(void) { } static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { const unsigned long MAJOR_MINOR = 0xFFFF0000UL; - if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) - return 0; - if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) - return 1; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) return 1; { char message[200]; PyOS_snprintf(message, sizeof(message), @@ -8610,11 +8876,9 @@ static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt "of module '%.100s' " "%s " "runtime version %d.%d", - (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), - __Pyx_MODULE_NAME, - (allow_newer) ? "was newer than" : "does not match", - (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) - ); + (int)(ct_version >> 24), (int)((ct_version >> 16) & 0xFF), __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", (int)(rt_version >> 24), + (int)((rt_version >> 16) & 0xFF)); return PyErr_WarnEx(NULL, message, 1); } } @@ -8633,18 +8897,16 @@ static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { } else { *str = PyBytes_FromStringAndSize(t.s, t.n - 1); } - if (!*str) - return -1; - if (PyObject_Hash(*str) == -1) - return -1; + if (!*str) return -1; + if (PyObject_Hash(*str) == -1) return -1; return 0; } #endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { - #if PY_MAJOR_VERSION >= 3 +#if PY_MAJOR_VERSION >= 3 __Pyx_InitString(*t, t->p); - #else +#else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { @@ -8652,11 +8914,9 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } - if (!*t->p) - return -1; - if (PyObject_Hash(*t->p) == -1) - return -1; - #endif + if (!*t->p) return -1; + if (PyObject_Hash(*t->p) == -1) return -1; +#endif ++t; } return 0; @@ -8665,39 +8925,39 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { #include static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { size_t len = strlen(s); - if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + if (unlikely(len > (size_t)PY_SSIZE_T_MAX)) { PyErr_SetString(PyExc_OverflowError, "byte string is too long"); return -1; } - return (Py_ssize_t) len; + return (Py_ssize_t)len; } -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_FromString(const char *c_str) { Py_ssize_t len = __Pyx_ssize_strlen(c_str); if (unlikely(len < 0)) return NULL; return __Pyx_PyUnicode_FromStringAndSize(c_str, len); } -static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { +static CYTHON_INLINE PyObject *__Pyx_PyByteArray_FromString(const char *c_str) { Py_ssize_t len = __Pyx_ssize_strlen(c_str); if (unlikely(len < 0)) return NULL; return PyByteArray_FromStringAndSize(c_str, len); } -static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { +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); +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; + char *end = defenc_c + PyBytes_GET_SIZE(defenc); + char *c; for (c = defenc_c; c < end; c++) { - if ((unsigned char) (*c) >= 128) { + if ((unsigned char)(*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } @@ -8708,7 +8968,7 @@ static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *leng return defenc_c; } #else -static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +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))) { @@ -8724,24 +8984,25 @@ static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py } #endif #endif -static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +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 && + __Pyx_sys_getdefaultencoding_not_ascii && #endif - PyUnicode_Check(o)) { + PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) - if (PyByteArray_Check(o)) { +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || \ + (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; + char *result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; @@ -8750,27 +9011,29 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ } } } -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_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) { +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) { +static PyObject *__Pyx_PyNumber_IntOrLongWrongResultType(PyObject *result, const char *type_name) { __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " - "The ability to return an instance of a strict subclass of int is deprecated, " - "and may be removed in a future version of Python.", - result_type_name)) { + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; @@ -8779,153 +9042,156 @@ static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const return result; } #endif - PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", - type_name, type_name, result_type_name); + PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", type_name, type_name, + result_type_name); __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +static CYTHON_INLINE PyObject *__Pyx_PyNumber_IntOrLong(PyObject *x) { #if CYTHON_USE_TYPE_SLOTS - PyNumberMethods *m; + PyNumberMethods *m; #endif - const char *name = NULL; - PyObject *res = NULL; + const char *name = NULL; + PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x) || PyLong_Check(x))) + if (likely(PyInt_Check(x) || PyLong_Check(x))) #else - if (likely(PyLong_Check(x))) + if (likely(PyLong_Check(x))) #endif - return __Pyx_NewRef(x); + 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)) { + m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 - if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { + 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 (unlikely(!PyLong_CheckExact(res))) { + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } #endif - return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); } - } - 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 - if (likely(__Pyx_PyLong_IsCompact(b))) { - return __Pyx_PyLong_CompactValue(b); - } else { - const digit* digits = __Pyx_PyLong_Digits(b); - const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); - switch (size) { - case 2: - if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { - return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -2: - if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case 3: - if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { - return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -3: - if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case 4: - if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { - return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -4: - if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - } - } - #endif - return PyLong_AsSsize_t(b); - } - x = PyNumber_Index(b); - if (!x) return -1; - ival = PyInt_AsSsize_t(x); - Py_DECREF(x); - return ival; -} -static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { - if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { - return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); + if (likely(res)) { #if PY_MAJOR_VERSION < 3 - } else if (likely(PyInt_CheckExact(o))) { - return PyInt_AS_LONG(o); + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { #endif - } else { + 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; - x = PyNumber_Index(o); +#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 + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); + } else { + const digit *digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); + 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_AsLong(x); + 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 Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject *o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t)__Pyx_PyIndex_AsSsize_t(o); +#if PY_MAJOR_VERSION < 3 + } else if (likely(PyInt_CheckExact(o))) { + return PyInt_AS_LONG(o); +#endif + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyInt_AsLong(x); + Py_DECREF(x); + return ival; + } } -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { - return PyInt_FromSize_t(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); } /* #### Code section: utility_code_pragmas_end ### */ #ifdef _MSC_VER -#pragma warning( pop ) +#pragma warning(pop) #endif - - /* #### Code section: end ### */ #endif /* Py_PYTHON_H */ diff --git a/src/perception/lidar_pipeline/lidar_pipeline/library/cy_library/total_least_squares.html b/src/perception/lidar_pipeline/lidar_pipeline/library/cy_library/total_least_squares.html index ab7a8c052..38bf56739 100644 --- a/src/perception/lidar_pipeline/lidar_pipeline/library/cy_library/total_least_squares.html +++ b/src/perception/lidar_pipeline/lidar_pipeline/library/cy_library/total_least_squares.html @@ -5,7 +5,7 @@ Cython: total_least_squares.pyx