From 8a02b9cdfdba90db7987fdd9136977051116733f Mon Sep 17 00:00:00 2001 From: Guillaume Pellerin Date: Fri, 17 Oct 2014 14:06:53 +0200 Subject: [PATCH 1/1] add first c, py, pyx benchs --- .gitignore | 2 + c/tictoc | Bin 0 -> 6981 bytes c/tictoc.c | 16 + py/.tictoc_1.py.kate-swp | Bin 0 -> 163 bytes py/tictoc_0.1.py | 13 + py/tictoc_0.py | 9 + py/tictoc_1.py | 12 + py/tictoc_2.py | 6 + py/tictoc_3.py | 5 + py/tt_test_2.py | 4 + py/tt_test_3.py | 4 + pyx/setup_0.py | 6 + pyx/setup_1.py | 6 + pyx/tictoc_0.c | 2140 ++++++++++++++++++++++++++++++++++++ pyx/tictoc_0.pyx | 8 + pyx/tictoc_0.so | Bin 0 -> 56324 bytes pyx/tictoc_1.c | 2228 ++++++++++++++++++++++++++++++++++++++ pyx/tictoc_1.pyx | 10 + pyx/tictoc_1.so | Bin 0 -> 64232 bytes 19 files changed, 4469 insertions(+) create mode 100644 .gitignore create mode 100755 c/tictoc create mode 100644 c/tictoc.c create mode 100644 py/.tictoc_1.py.kate-swp create mode 100644 py/tictoc_0.1.py create mode 100644 py/tictoc_0.py create mode 100644 py/tictoc_1.py create mode 100644 py/tictoc_2.py create mode 100644 py/tictoc_3.py create mode 100644 py/tt_test_2.py create mode 100644 py/tt_test_3.py create mode 100644 pyx/setup_0.py create mode 100644 pyx/setup_1.py create mode 100644 pyx/tictoc_0.c create mode 100644 pyx/tictoc_0.pyx create mode 100755 pyx/tictoc_0.so create mode 100644 pyx/tictoc_1.c create mode 100644 pyx/tictoc_1.pyx create mode 100755 pyx/tictoc_1.so diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9ba605c --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +build +*-swp diff --git a/c/tictoc b/c/tictoc new file mode 100755 index 0000000000000000000000000000000000000000..76eb29d6210e61ea64f62323cce06938644f6be2 GIT binary patch literal 6981 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 x5zv^?wG==#W)n96ikElw=8@Cpakc8L$!Io +#include +int main() +{ + clock_t t1, t2; + int i,b; + long clk_tck = CLOCKS_PER_SEC; + + t1 = clock(); + for(i=0;i< 10000000;++i) + b = i; + t2 = clock(); + + printf("Elapsed time: %lf\n", (double)(t2-t1)/(double)clk_tck); + return 0; +} diff --git a/py/.tictoc_1.py.kate-swp b/py/.tictoc_1.py.kate-swp new file mode 100644 index 0000000000000000000000000000000000000000..4d78e2de884e22c8393d422dde1214cb0f412e11 GIT binary patch literal 163 zcmZQzV36@nEJ;-eE>A2_aLdd|RnS!kOD!tS%+FIW)H4VUVqjq40%8zg^8^ww4r769 xFpSR#6lW|#@R>mTOaz}9#Lq+USwQ>}1fLbeS8xSe#tmeH0GDfUD3IcI1puZx6FdL_ literal 0 HcmV?d00001 diff --git a/py/tictoc_0.1.py b/py/tictoc_0.1.py new file mode 100644 index 0000000..95b136f --- /dev/null +++ b/py/tictoc_0.1.py @@ -0,0 +1,13 @@ +import time + +tic = time.time() +i=0 + +while True: + b=i + if b == 10000000: + break + i+=1 + +toc = time.time()-tic +print(toc) diff --git a/py/tictoc_0.py b/py/tictoc_0.py new file mode 100644 index 0000000..6d6ca35 --- /dev/null +++ b/py/tictoc_0.py @@ -0,0 +1,9 @@ +import time + +tic = time.time() + +for i in range(0,10000000): + b=i + +toc = time.time()-tic +print(toc) diff --git a/py/tictoc_1.py b/py/tictoc_1.py new file mode 100644 index 0000000..79b020d --- /dev/null +++ b/py/tictoc_1.py @@ -0,0 +1,12 @@ +import time + +tic = time.time(); + +def test(): + for i in range(0,10000000): + b=i + +tic = time.time() +test() +toc = time.time()-tic +print(toc) diff --git a/py/tictoc_2.py b/py/tictoc_2.py new file mode 100644 index 0000000..bbb43d3 --- /dev/null +++ b/py/tictoc_2.py @@ -0,0 +1,6 @@ + +def test(): + for i in range(0,10000000): + b=i + +test() diff --git a/py/tictoc_3.py b/py/tictoc_3.py new file mode 100644 index 0000000..661b32b --- /dev/null +++ b/py/tictoc_3.py @@ -0,0 +1,5 @@ + +def test(i): + b=i + + diff --git a/py/tt_test_2.py b/py/tt_test_2.py new file mode 100644 index 0000000..7a0d77c --- /dev/null +++ b/py/tt_test_2.py @@ -0,0 +1,4 @@ +import timeit + +t = timeit.Timer("tictoc_2.test()", "import tictoc_2") +print t.timeit(1) diff --git a/py/tt_test_3.py b/py/tt_test_3.py new file mode 100644 index 0000000..7a5e193 --- /dev/null +++ b/py/tt_test_3.py @@ -0,0 +1,4 @@ +import timeit + +t = timeit.Timer("tictoc_3.test(1)", "import tictoc_3") +print t.timeit(10000000) diff --git a/pyx/setup_0.py b/pyx/setup_0.py new file mode 100644 index 0000000..f20d1a5 --- /dev/null +++ b/pyx/setup_0.py @@ -0,0 +1,6 @@ +from distutils.core import setup +from Cython.Build import cythonize + +setup( + ext_modules=cythonize("tictoc_0.pyx"), +) \ No newline at end of file diff --git a/pyx/setup_1.py b/pyx/setup_1.py new file mode 100644 index 0000000..ecea8d3 --- /dev/null +++ b/pyx/setup_1.py @@ -0,0 +1,6 @@ +from distutils.core import setup +from Cython.Build import cythonize + +setup( + ext_modules=cythonize("tictoc_1.pyx"), +) \ No newline at end of file diff --git a/pyx/tictoc_0.c b/pyx/tictoc_0.c new file mode 100644 index 0000000..eb8e3c0 --- /dev/null +++ b/pyx/tictoc_0.c @@ -0,0 +1,2140 @@ +/* Generated by Cython 0.19.1 on Thu Oct 16 02:32:57 2014 */ + +#define PY_SSIZE_T_CLEAN +#ifndef CYTHON_USE_PYLONG_INTERNALS +#ifdef PYLONG_BITS_IN_DIGIT +#define CYTHON_USE_PYLONG_INTERNALS 0 +#else +#include "pyconfig.h" +#ifdef PYLONG_BITS_IN_DIGIT +#define CYTHON_USE_PYLONG_INTERNALS 1 +#else +#define CYTHON_USE_PYLONG_INTERNALS 0 +#endif +#endif +#endif +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02040000 + #error Cython requires Python 2.4+. +#else +#include /* For offsetof */ +#ifndef offsetof +#define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION +#define CYTHON_COMPILING_IN_PYPY 1 +#define CYTHON_COMPILING_IN_CPYTHON 0 +#else +#define CYTHON_COMPILING_IN_PYPY 0 +#define CYTHON_COMPILING_IN_CPYTHON 1 +#endif +#if PY_VERSION_HEX < 0x02050000 + typedef int Py_ssize_t; + #define PY_SSIZE_T_MAX INT_MAX + #define PY_SSIZE_T_MIN INT_MIN + #define PY_FORMAT_SIZE_T "" + #define CYTHON_FORMAT_SSIZE_T "" + #define PyInt_FromSsize_t(z) PyInt_FromLong(z) + #define PyInt_AsSsize_t(o) __Pyx_PyInt_AsInt(o) + #define PyNumber_Index(o) ((PyNumber_Check(o) && !PyFloat_Check(o)) ? PyNumber_Int(o) : \ + (PyErr_Format(PyExc_TypeError, \ + "expected index value, got %.200s", Py_TYPE(o)->tp_name), \ + (PyObject*)0)) + #define __Pyx_PyIndex_Check(o) (PyNumber_Check(o) && !PyFloat_Check(o) && \ + !PyComplex_Check(o)) + #define PyIndex_Check __Pyx_PyIndex_Check + #define PyErr_WarnEx(category, message, stacklevel) PyErr_Warn(category, message) + #define __PYX_BUILD_PY_SSIZE_T "i" +#else + #define __PYX_BUILD_PY_SSIZE_T "n" + #define CYTHON_FORMAT_SSIZE_T "z" + #define __Pyx_PyIndex_Check PyIndex_Check +#endif +#if PY_VERSION_HEX < 0x02060000 + #define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt) + #define Py_TYPE(ob) (((PyObject*)(ob))->ob_type) + #define Py_SIZE(ob) (((PyVarObject*)(ob))->ob_size) + #define PyVarObject_HEAD_INIT(type, size) \ + PyObject_HEAD_INIT(type) size, + #define PyType_Modified(t) + typedef struct { + void *buf; + PyObject *obj; + Py_ssize_t len; + Py_ssize_t itemsize; + int readonly; + int ndim; + char *format; + Py_ssize_t *shape; + Py_ssize_t *strides; + Py_ssize_t *suboffsets; + void *internal; + } Py_buffer; + #define PyBUF_SIMPLE 0 + #define PyBUF_WRITABLE 0x0001 + #define PyBUF_FORMAT 0x0004 + #define PyBUF_ND 0x0008 + #define PyBUF_STRIDES (0x0010 | PyBUF_ND) + #define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES) + #define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES) + #define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES) + #define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES) + #define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_FORMAT | PyBUF_WRITABLE) + #define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_FORMAT | PyBUF_WRITABLE) + typedef int (*getbufferproc)(PyObject *, Py_buffer *, int); + typedef void (*releasebufferproc)(PyObject *, Py_buffer *); +#endif +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ + PyCode_New(a, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif +#if PY_MAJOR_VERSION < 3 && PY_MINOR_VERSION < 6 + #define PyUnicode_FromString(s) PyUnicode_Decode(s, strlen(s), "UTF-8", "strict") +#endif +#if PY_MAJOR_VERSION >= 3 + #define Py_TPFLAGS_CHECKTYPES 0 + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#if (PY_VERSION_HEX < 0x02060000) || (PY_MAJOR_VERSION >= 3) + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#if PY_VERSION_HEX < 0x02060000 + #define Py_TPFLAGS_HAVE_VERSION_TAG 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ? \ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) +#else + #define CYTHON_PEP393_ENABLED 0 + #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_READ(k, d, i) ((k=k), (Py_UCS4)(((Py_UNICODE*)d)[i])) +#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 +#endif +#if PY_VERSION_HEX < 0x02060000 + #define PyBytesObject PyStringObject + #define PyBytes_Type PyString_Type + #define PyBytes_Check PyString_Check + #define PyBytes_CheckExact PyString_CheckExact + #define PyBytes_FromString PyString_FromString + #define PyBytes_FromStringAndSize PyString_FromStringAndSize + #define PyBytes_FromFormat PyString_FromFormat + #define PyBytes_DecodeEscape PyString_DecodeEscape + #define PyBytes_AsString PyString_AsString + #define PyBytes_AsStringAndSize PyString_AsStringAndSize + #define PyBytes_Size PyString_Size + #define PyBytes_AS_STRING PyString_AS_STRING + #define PyBytes_GET_SIZE PyString_GET_SIZE + #define PyBytes_Repr PyString_Repr + #define PyBytes_Concat PyString_Concat + #define PyBytes_ConcatAndDel PyString_ConcatAndDel +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj) || \ + PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (Py_TYPE(obj) == &PyBaseString_Type) +#endif +#if PY_VERSION_HEX < 0x02060000 + #define PySet_Check(obj) PyObject_TypeCheck(obj, &PySet_Type) + #define PyFrozenSet_Check(obj) PyObject_TypeCheck(obj, &PyFrozenSet_Type) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_VERSION_HEX < 0x03020000 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if (PY_MAJOR_VERSION < 3) || (PY_VERSION_HEX >= 0x03010300) + #define __Pyx_PySequence_GetSlice(obj, a, b) PySequence_GetSlice(obj, a, b) + #define __Pyx_PySequence_SetSlice(obj, a, b, value) PySequence_SetSlice(obj, a, b, value) + #define __Pyx_PySequence_DelSlice(obj, a, b) PySequence_DelSlice(obj, a, b) +#else + #define __Pyx_PySequence_GetSlice(obj, a, b) (unlikely(!(obj)) ? \ + (PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), (PyObject*)0) : \ + (likely((obj)->ob_type->tp_as_mapping) ? (PySequence_GetSlice(obj, a, b)) : \ + (PyErr_Format(PyExc_TypeError, "'%.200s' object is unsliceable", (obj)->ob_type->tp_name), (PyObject*)0))) + #define __Pyx_PySequence_SetSlice(obj, a, b, value) (unlikely(!(obj)) ? \ + (PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), -1) : \ + (likely((obj)->ob_type->tp_as_mapping) ? (PySequence_SetSlice(obj, a, b, value)) : \ + (PyErr_Format(PyExc_TypeError, "'%.200s' object doesn't support slice assignment", (obj)->ob_type->tp_name), -1))) + #define __Pyx_PySequence_DelSlice(obj, a, b) (unlikely(!(obj)) ? \ + (PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), -1) : \ + (likely((obj)->ob_type->tp_as_mapping) ? (PySequence_DelSlice(obj, a, b)) : \ + (PyErr_Format(PyExc_TypeError, "'%.200s' object doesn't support slice deletion", (obj)->ob_type->tp_name), -1))) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#endif +#if PY_VERSION_HEX < 0x02050000 + #define __Pyx_GetAttrString(o,n) PyObject_GetAttrString((o),((char *)(n))) + #define __Pyx_SetAttrString(o,n,a) PyObject_SetAttrString((o),((char *)(n)),(a)) + #define __Pyx_DelAttrString(o,n) PyObject_DelAttrString((o),((char *)(n))) +#else + #define __Pyx_GetAttrString(o,n) PyObject_GetAttrString((o),(n)) + #define __Pyx_SetAttrString(o,n,a) PyObject_SetAttrString((o),(n),(a)) + #define __Pyx_DelAttrString(o,n) PyObject_DelAttrString((o),(n)) +#endif +#if PY_VERSION_HEX < 0x02050000 + #define __Pyx_NAMESTR(n) ((char *)(n)) + #define __Pyx_DOCSTR(n) ((char *)(n)) +#else + #define __Pyx_NAMESTR(n) (n) + #define __Pyx_DOCSTR(n) (n) +#endif +#ifndef CYTHON_INLINE + #if 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 +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + /* Initialize NaN. The sign is irrelevant, an exponent with all bits 1 and + a nonzero mantissa means NaN. If the first bit in the mantissa is 1, it is + a quiet NaN. */ + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif + + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) +#define _USE_MATH_DEFINES +#endif +#include +#define __PYX_HAVE__tictoc_0 +#define __PYX_HAVE_API__tictoc_0 +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; /*proto*/ + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(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_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromUString(s) __Pyx_PyObject_FromString((char*)s) +#define __Pyx_PyBytes_FromUString(s) __Pyx_PyBytes_FromString((char*)s) +#define __Pyx_PyStr_FromUString(s) __Pyx_PyStr_FromString((char*)s) +#define __Pyx_PyUnicode_FromUString(s) __Pyx_PyUnicode_FromString((char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return u_end - u - 1; +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_Owned_Py_None(b) (Py_INCREF(Py_None), Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? (Py_INCREF(Py_True), Py_True) : (Py_INCREF(Py_False), Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +static CYTHON_INLINE size_t __Pyx_PyInt_AsSize_t(PyObject*); +#if CYTHON_COMPILING_IN_CPYTHON +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params() { + PyObject* sys = NULL; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + sys = PyImport_ImportModule("sys"); + if (sys == NULL) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + if (default_encoding == NULL) goto bad; + if (strcmp(PyBytes_AsString(default_encoding), "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + const char* default_encoding_c = PyBytes_AS_STRING(default_encoding); + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (ascii_chars_u == NULL) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (ascii_chars_b == NULL || strncmp(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 '%s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + } + Py_XDECREF(sys); + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return 0; +bad: + Py_XDECREF(sys); + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params() { + PyObject* sys = NULL; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (sys == NULL) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + if (default_encoding == NULL) goto bad; + default_encoding_c = PyBytes_AS_STRING(default_encoding); + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(sys); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(sys); + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +#ifdef __GNUC__ + /* Test for GCC > 2.95 */ + #if __GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) + #else /* __GNUC__ > 2 ... */ + #define likely(x) (x) + #define unlikely(x) (x) + #endif /* __GNUC__ > 2 ... */ +#else /* __GNUC__ */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "tictoc_0.pyx", +}; + +/*--- Type declarations ---*/ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); /*proto*/ + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil) \ + if (acquire_gil) { \ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ + PyGILState_Release(__pyx_gilstate_save); \ + } else { \ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil) \ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext() \ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif /* CYTHON_REFNANNY */ +#define __Pyx_XDECREF_SET(r, v) do { \ + PyObject *tmp = (PyObject *) r; \ + r = v; __Pyx_XDECREF(tmp); \ + } while (0) +#define __Pyx_DECREF_SET(r, v) do { \ + PyObject *tmp = (PyObject *) r; \ + r = v; __Pyx_DECREF(tmp); \ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +static PyObject *__Pyx_GetBuiltinName(PyObject *name); /*proto*/ + +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); /*proto*/ + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /*proto*/ + +static int __Pyx_Print(PyObject*, PyObject *, int); /*proto*/ +#if CYTHON_COMPILING_IN_PYPY || PY_MAJOR_VERSION >= 3 +static PyObject* __pyx_print = 0; +static PyObject* __pyx_print_kwargs = 0; +#endif + +static int __Pyx_PrintOne(PyObject* stream, PyObject *o); /*proto*/ + +static CYTHON_INLINE unsigned char __Pyx_PyInt_AsUnsignedChar(PyObject *); + +static CYTHON_INLINE unsigned short __Pyx_PyInt_AsUnsignedShort(PyObject *); + +static CYTHON_INLINE unsigned int __Pyx_PyInt_AsUnsignedInt(PyObject *); + +static CYTHON_INLINE char __Pyx_PyInt_AsChar(PyObject *); + +static CYTHON_INLINE short __Pyx_PyInt_AsShort(PyObject *); + +static CYTHON_INLINE int __Pyx_PyInt_AsInt(PyObject *); + +static CYTHON_INLINE signed char __Pyx_PyInt_AsSignedChar(PyObject *); + +static CYTHON_INLINE signed short __Pyx_PyInt_AsSignedShort(PyObject *); + +static CYTHON_INLINE signed int __Pyx_PyInt_AsSignedInt(PyObject *); + +static CYTHON_INLINE int __Pyx_PyInt_AsLongDouble(PyObject *); + +static CYTHON_INLINE unsigned long __Pyx_PyInt_AsUnsignedLong(PyObject *); + +static CYTHON_INLINE unsigned PY_LONG_LONG __Pyx_PyInt_AsUnsignedLongLong(PyObject *); + +static CYTHON_INLINE long __Pyx_PyInt_AsLong(PyObject *); + +static CYTHON_INLINE PY_LONG_LONG __Pyx_PyInt_AsLongLong(PyObject *); + +static CYTHON_INLINE signed long __Pyx_PyInt_AsSignedLong(PyObject *); + +static CYTHON_INLINE signed PY_LONG_LONG __Pyx_PyInt_AsSignedLongLong(PyObject *); + +static int __Pyx_check_binary_version(void); + +typedef struct { + int code_line; + PyCodeObject* code_object; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); /*proto*/ + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /*proto*/ + + +/* Module declarations from 'tictoc_0' */ +#define __Pyx_MODULE_NAME "tictoc_0" +int __pyx_module_is_main_tictoc_0 = 0; + +/* Implementation of 'tictoc_0' */ +static PyObject *__pyx_builtin_range; +static char __pyx_k__b[] = "b"; +static char __pyx_k__i[] = "i"; +static char __pyx_k__end[] = "end"; +static char __pyx_k__tic[] = "tic"; +static char __pyx_k__file[] = "file"; +static char __pyx_k__time[] = "time"; +static char __pyx_k__print[] = "print"; +static char __pyx_k__range[] = "range"; +static char __pyx_k____main__[] = "__main__"; +static char __pyx_k____test__[] = "__test__"; +static char __pyx_k____import__[] = "__import__"; +static PyObject *__pyx_n_s____import__; +static PyObject *__pyx_n_s____main__; +static PyObject *__pyx_n_s____test__; +static PyObject *__pyx_n_s__b; +static PyObject *__pyx_n_s__end; +static PyObject *__pyx_n_s__file; +static PyObject *__pyx_n_s__i; +static PyObject *__pyx_n_s__print; +static PyObject *__pyx_n_s__range; +static PyObject *__pyx_n_s__tic; +static PyObject *__pyx_n_s__time; +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_10000000; +static PyObject *__pyx_k_tuple_1; + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + __Pyx_NAMESTR("tictoc_0"), + 0, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s____import__, __pyx_k____import__, sizeof(__pyx_k____import__), 0, 0, 1, 1}, + {&__pyx_n_s____main__, __pyx_k____main__, sizeof(__pyx_k____main__), 0, 0, 1, 1}, + {&__pyx_n_s____test__, __pyx_k____test__, sizeof(__pyx_k____test__), 0, 0, 1, 1}, + {&__pyx_n_s__b, __pyx_k__b, sizeof(__pyx_k__b), 0, 0, 1, 1}, + {&__pyx_n_s__end, __pyx_k__end, sizeof(__pyx_k__end), 0, 0, 1, 1}, + {&__pyx_n_s__file, __pyx_k__file, sizeof(__pyx_k__file), 0, 0, 1, 1}, + {&__pyx_n_s__i, __pyx_k__i, sizeof(__pyx_k__i), 0, 0, 1, 1}, + {&__pyx_n_s__print, __pyx_k__print, sizeof(__pyx_k__print), 0, 0, 1, 1}, + {&__pyx_n_s__range, __pyx_k__range, sizeof(__pyx_k__range), 0, 0, 1, 1}, + {&__pyx_n_s__tic, __pyx_k__tic, sizeof(__pyx_k__tic), 0, 0, 1, 1}, + {&__pyx_n_s__time, __pyx_k__time, sizeof(__pyx_k__time), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s__range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "tictoc_0.pyx":5 + * tic = time.time() + * + * for i in range(0,10000000): # <<<<<<<<<<<<<< + * b=i + * + */ + __pyx_k_tuple_1 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_10000000); if (unlikely(!__pyx_k_tuple_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_k_tuple_1); + __Pyx_GIVEREF(((PyObject *)__pyx_k_tuple_1)); + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __pyx_int_10000000 = PyInt_FromLong(10000000); if (unlikely(!__pyx_int_10000000)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC inittictoc_0(void); /*proto*/ +PyMODINIT_FUNC inittictoc_0(void) +#else +PyMODINIT_FUNC PyInit_tictoc_0(void); /*proto*/ +PyMODINIT_FUNC PyInit_tictoc_0(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #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("PyMODINIT_FUNC PyInit_tictoc_0(void)", 0); + if ( __Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #ifdef __Pyx_CyFunction_USED + if (__Pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4(__Pyx_NAMESTR("tictoc_0"), __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + Py_INCREF(__pyx_d); + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!PyDict_GetItemString(modules, "tictoc_0")) { + if (unlikely(PyDict_SetItemString(modules, "tictoc_0", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + __pyx_b = PyImport_AddModule(__Pyx_NAMESTR(__Pyx_BUILTIN_MODULE_NAME)); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (__Pyx_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + /*--- Initialize various global constants etc. ---*/ + if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + if (__pyx_module_is_main_tictoc_0) { + if (__Pyx_SetAttrString(__pyx_m, "__name__", __pyx_n_s____main__) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + } + /*--- Builtin init code ---*/ + if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Constants init code ---*/ + if (unlikely(__Pyx_InitCachedConstants() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + /*--- Type init code ---*/ + /*--- Type import code ---*/ + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + /*--- Execution code ---*/ + + /* "tictoc_0.pyx":1 + * import time # <<<<<<<<<<<<<< + * + * tic = time.time() + */ + __pyx_t_1 = __Pyx_Import(((PyObject *)__pyx_n_s__time), 0, -1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s__time, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "tictoc_0.pyx":3 + * import time + * + * tic = time.time() # <<<<<<<<<<<<<< + * + * for i in range(0,10000000): + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s__time); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s__time); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_Call(__pyx_t_2, ((PyObject *)__pyx_empty_tuple), NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s__tic, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "tictoc_0.pyx":5 + * tic = time.time() + * + * for i in range(0,10000000): # <<<<<<<<<<<<<< + * b=i + * + */ + __pyx_t_1 = PyObject_Call(__pyx_builtin_range, ((PyObject *)__pyx_k_tuple_1), NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyList_CheckExact(__pyx_t_1) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (!__pyx_t_4 && PyList_CheckExact(__pyx_t_2)) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + } else if (!__pyx_t_4 && PyTuple_CheckExact(__pyx_t_2)) { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + } else { + __pyx_t_1 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_1)) { + if (PyErr_Occurred()) { + if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) PyErr_Clear(); + else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + if (PyDict_SetItem(__pyx_d, __pyx_n_s__i, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "tictoc_0.pyx":6 + * + * for i in range(0,10000000): + * b=i # <<<<<<<<<<<<<< + * + * print time.time()-tic + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s__i); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 6; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s__b, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 6; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "tictoc_0.pyx":8 + * b=i + * + * print time.time()-tic # <<<<<<<<<<<<<< + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s__time); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s__time); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_Call(__pyx_t_1, ((PyObject *)__pyx_empty_tuple), NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s__tic); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PyNumber_Subtract(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__Pyx_PrintOne(0, __pyx_t_5) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "tictoc_0.pyx":1 + * import time # <<<<<<<<<<<<<< + * + * tic = time.time() + */ + __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(((PyObject *)__pyx_t_5)); + if (PyDict_SetItem(__pyx_d, __pyx_n_s____test__, ((PyObject *)__pyx_t_5)) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(((PyObject *)__pyx_t_5)); __pyx_t_5 = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + if (__pyx_m) { + __Pyx_AddTraceback("init tictoc_0", __pyx_clineno, __pyx_lineno, __pyx_filename); + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init tictoc_0"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* Runtime support code */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif /* CYTHON_REFNANNY */ + +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if CYTHON_COMPILING_IN_CPYTHON + result = PyDict_GetItem(__pyx_d, name); + if (result) { + Py_INCREF(result); + } else { +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s____import__); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + #if PY_VERSION_HEX >= 0x02050000 + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; /* try absolute import on failure */ + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } + #else + if (level>0) { + PyErr_SetString(PyExc_RuntimeError, "Relative import is not supported for Python <=2.4."); + goto bad; + } + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, NULL); + #endif +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +#if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION < 3 +static PyObject *__Pyx_GetStdout(void) { + PyObject *f = PySys_GetObject((char *)"stdout"); + if (!f) { + PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout"); + } + return f; +} +static int __Pyx_Print(PyObject* f, PyObject *arg_tuple, int newline) { + int i; + if (!f) { + if (!(f = __Pyx_GetStdout())) + return -1; + } + Py_INCREF(f); + for (i=0; i < PyTuple_GET_SIZE(arg_tuple); i++) { + PyObject* v; + if (PyFile_SoftSpace(f, 1)) { + if (PyFile_WriteString(" ", f) < 0) + goto error; + } + v = PyTuple_GET_ITEM(arg_tuple, i); + if (PyFile_WriteObject(v, f, Py_PRINT_RAW) < 0) + goto error; + if (PyString_Check(v)) { + char *s = PyString_AsString(v); + Py_ssize_t len = PyString_Size(v); + if (len > 0 && + isspace(Py_CHARMASK(s[len-1])) && + s[len-1] != ' ') + PyFile_SoftSpace(f, 0); + } + } + if (newline) { + if (PyFile_WriteString("\n", f) < 0) + goto error; + PyFile_SoftSpace(f, 0); + } + Py_DECREF(f); + return 0; +error: + Py_DECREF(f); + return -1; +} +#else /* Python 3 has a print function */ +static int __Pyx_Print(PyObject* stream, PyObject *arg_tuple, int newline) { + PyObject* kwargs = 0; + PyObject* result = 0; + PyObject* end_string; + if (unlikely(!__pyx_print)) { + __pyx_print = PyObject_GetAttr(__pyx_b, __pyx_n_s__print); + if (!__pyx_print) + return -1; + } + if (stream) { + kwargs = PyDict_New(); + if (unlikely(!kwargs)) + return -1; + if (unlikely(PyDict_SetItem(kwargs, __pyx_n_s__file, stream) < 0)) + goto bad; + if (!newline) { + end_string = PyUnicode_FromStringAndSize(" ", 1); + if (unlikely(!end_string)) + goto bad; + if (PyDict_SetItem(kwargs, __pyx_n_s__end, end_string) < 0) { + Py_DECREF(end_string); + goto bad; + } + Py_DECREF(end_string); + } + } else if (!newline) { + if (unlikely(!__pyx_print_kwargs)) { + __pyx_print_kwargs = PyDict_New(); + if (unlikely(!__pyx_print_kwargs)) + return -1; + end_string = PyUnicode_FromStringAndSize(" ", 1); + if (unlikely(!end_string)) + return -1; + if (PyDict_SetItem(__pyx_print_kwargs, __pyx_n_s__end, end_string) < 0) { + Py_DECREF(end_string); + return -1; + } + Py_DECREF(end_string); + } + kwargs = __pyx_print_kwargs; + } + result = PyObject_Call(__pyx_print, arg_tuple, kwargs); + if (unlikely(kwargs) && (kwargs != __pyx_print_kwargs)) + Py_DECREF(kwargs); + if (!result) + return -1; + Py_DECREF(result); + return 0; +bad: + if (kwargs != __pyx_print_kwargs) + Py_XDECREF(kwargs); + return -1; +} +#endif + +#if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION < 3 +static int __Pyx_PrintOne(PyObject* f, PyObject *o) { + if (!f) { + if (!(f = __Pyx_GetStdout())) + return -1; + } + Py_INCREF(f); + if (PyFile_SoftSpace(f, 0)) { + if (PyFile_WriteString(" ", f) < 0) + goto error; + } + if (PyFile_WriteObject(o, f, Py_PRINT_RAW) < 0) + goto error; + if (PyFile_WriteString("\n", f) < 0) + goto error; + Py_DECREF(f); + return 0; +error: + Py_DECREF(f); + return -1; + /* the line below is just to avoid C compiler + * warnings about unused functions */ + return __Pyx_Print(f, NULL, 0); +} +#else /* Python 3 has a print function */ +static int __Pyx_PrintOne(PyObject* stream, PyObject *o) { + int res; + PyObject* arg_tuple = PyTuple_Pack(1, o); + if (unlikely(!arg_tuple)) + return -1; + res = __Pyx_Print(stream, arg_tuple, 1); + Py_DECREF(arg_tuple); + return res; +} +#endif + +static CYTHON_INLINE unsigned char __Pyx_PyInt_AsUnsignedChar(PyObject* x) { + const unsigned char neg_one = (unsigned char)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(unsigned char) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(unsigned char)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to unsigned char" : + "value too large to convert to unsigned char"); + } + return (unsigned char)-1; + } + return (unsigned char)val; + } + return (unsigned char)__Pyx_PyInt_AsUnsignedLong(x); +} + +static CYTHON_INLINE unsigned short __Pyx_PyInt_AsUnsignedShort(PyObject* x) { + const unsigned short neg_one = (unsigned short)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(unsigned short) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(unsigned short)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to unsigned short" : + "value too large to convert to unsigned short"); + } + return (unsigned short)-1; + } + return (unsigned short)val; + } + return (unsigned short)__Pyx_PyInt_AsUnsignedLong(x); +} + +static CYTHON_INLINE unsigned int __Pyx_PyInt_AsUnsignedInt(PyObject* x) { + const unsigned int neg_one = (unsigned int)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(unsigned int) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(unsigned int)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to unsigned int" : + "value too large to convert to unsigned int"); + } + return (unsigned int)-1; + } + return (unsigned int)val; + } + return (unsigned int)__Pyx_PyInt_AsUnsignedLong(x); +} + +static CYTHON_INLINE char __Pyx_PyInt_AsChar(PyObject* x) { + const char neg_one = (char)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(char) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(char)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to char" : + "value too large to convert to char"); + } + return (char)-1; + } + return (char)val; + } + return (char)__Pyx_PyInt_AsLong(x); +} + +static CYTHON_INLINE short __Pyx_PyInt_AsShort(PyObject* x) { + const short neg_one = (short)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(short) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(short)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to short" : + "value too large to convert to short"); + } + return (short)-1; + } + return (short)val; + } + return (short)__Pyx_PyInt_AsLong(x); +} + +static CYTHON_INLINE int __Pyx_PyInt_AsInt(PyObject* x) { + const int neg_one = (int)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(int) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(int)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to int" : + "value too large to convert to int"); + } + return (int)-1; + } + return (int)val; + } + return (int)__Pyx_PyInt_AsLong(x); +} + +static CYTHON_INLINE signed char __Pyx_PyInt_AsSignedChar(PyObject* x) { + const signed char neg_one = (signed char)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(signed char) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(signed char)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to signed char" : + "value too large to convert to signed char"); + } + return (signed char)-1; + } + return (signed char)val; + } + return (signed char)__Pyx_PyInt_AsSignedLong(x); +} + +static CYTHON_INLINE signed short __Pyx_PyInt_AsSignedShort(PyObject* x) { + const signed short neg_one = (signed short)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(signed short) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(signed short)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to signed short" : + "value too large to convert to signed short"); + } + return (signed short)-1; + } + return (signed short)val; + } + return (signed short)__Pyx_PyInt_AsSignedLong(x); +} + +static CYTHON_INLINE signed int __Pyx_PyInt_AsSignedInt(PyObject* x) { + const signed int neg_one = (signed int)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(signed int) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(signed int)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to signed int" : + "value too large to convert to signed int"); + } + return (signed int)-1; + } + return (signed int)val; + } + return (signed int)__Pyx_PyInt_AsSignedLong(x); +} + +static CYTHON_INLINE int __Pyx_PyInt_AsLongDouble(PyObject* x) { + const int neg_one = (int)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(int) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(int)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to int" : + "value too large to convert to int"); + } + return (int)-1; + } + return (int)val; + } + return (int)__Pyx_PyInt_AsLong(x); +} + +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS +#include "longintrepr.h" +#endif +#endif +static CYTHON_INLINE unsigned long __Pyx_PyInt_AsUnsignedLong(PyObject* x) { + const unsigned long neg_one = (unsigned long)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned long"); + return (unsigned long)-1; + } + return (unsigned long)val; + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(unsigned long)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return (unsigned long) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + if (unlikely(Py_SIZE(x) < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned long"); + return (unsigned long)-1; + } + return (unsigned long)PyLong_AsUnsignedLong(x); + } else { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(unsigned long)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return +(unsigned long) ((PyLongObject*)x)->ob_digit[0]; + case -1: return -(unsigned long) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + return (unsigned long)PyLong_AsLong(x); + } + } else { + unsigned long val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (unsigned long)-1; + val = __Pyx_PyInt_AsUnsignedLong(tmp); + Py_DECREF(tmp); + return val; + } +} + +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS +#include "longintrepr.h" +#endif +#endif +static CYTHON_INLINE unsigned PY_LONG_LONG __Pyx_PyInt_AsUnsignedLongLong(PyObject* x) { + const unsigned PY_LONG_LONG neg_one = (unsigned PY_LONG_LONG)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned PY_LONG_LONG"); + return (unsigned PY_LONG_LONG)-1; + } + return (unsigned PY_LONG_LONG)val; + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(unsigned PY_LONG_LONG)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return (unsigned PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + if (unlikely(Py_SIZE(x) < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned PY_LONG_LONG"); + return (unsigned PY_LONG_LONG)-1; + } + return (unsigned PY_LONG_LONG)PyLong_AsUnsignedLongLong(x); + } else { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(unsigned PY_LONG_LONG)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return +(unsigned PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + case -1: return -(unsigned PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + return (unsigned PY_LONG_LONG)PyLong_AsLongLong(x); + } + } else { + unsigned PY_LONG_LONG val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (unsigned PY_LONG_LONG)-1; + val = __Pyx_PyInt_AsUnsignedLongLong(tmp); + Py_DECREF(tmp); + return val; + } +} + +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS +#include "longintrepr.h" +#endif +#endif +static CYTHON_INLINE long __Pyx_PyInt_AsLong(PyObject* x) { + const long neg_one = (long)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long)-1; + } + return (long)val; + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(long)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return (long) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + if (unlikely(Py_SIZE(x) < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long)-1; + } + return (long)PyLong_AsUnsignedLong(x); + } else { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(long)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return +(long) ((PyLongObject*)x)->ob_digit[0]; + case -1: return -(long) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + return (long)PyLong_AsLong(x); + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (long)-1; + val = __Pyx_PyInt_AsLong(tmp); + Py_DECREF(tmp); + return val; + } +} + +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS +#include "longintrepr.h" +#endif +#endif +static CYTHON_INLINE PY_LONG_LONG __Pyx_PyInt_AsLongLong(PyObject* x) { + const PY_LONG_LONG neg_one = (PY_LONG_LONG)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to PY_LONG_LONG"); + return (PY_LONG_LONG)-1; + } + return (PY_LONG_LONG)val; + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(PY_LONG_LONG)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return (PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + if (unlikely(Py_SIZE(x) < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to PY_LONG_LONG"); + return (PY_LONG_LONG)-1; + } + return (PY_LONG_LONG)PyLong_AsUnsignedLongLong(x); + } else { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(PY_LONG_LONG)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return +(PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + case -1: return -(PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + return (PY_LONG_LONG)PyLong_AsLongLong(x); + } + } else { + PY_LONG_LONG val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (PY_LONG_LONG)-1; + val = __Pyx_PyInt_AsLongLong(tmp); + Py_DECREF(tmp); + return val; + } +} + +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS +#include "longintrepr.h" +#endif +#endif +static CYTHON_INLINE signed long __Pyx_PyInt_AsSignedLong(PyObject* x) { + const signed long neg_one = (signed long)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to signed long"); + return (signed long)-1; + } + return (signed long)val; + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(signed long)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return (signed long) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + if (unlikely(Py_SIZE(x) < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to signed long"); + return (signed long)-1; + } + return (signed long)PyLong_AsUnsignedLong(x); + } else { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(signed long)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return +(signed long) ((PyLongObject*)x)->ob_digit[0]; + case -1: return -(signed long) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + return (signed long)PyLong_AsLong(x); + } + } else { + signed long val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (signed long)-1; + val = __Pyx_PyInt_AsSignedLong(tmp); + Py_DECREF(tmp); + return val; + } +} + +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS +#include "longintrepr.h" +#endif +#endif +static CYTHON_INLINE signed PY_LONG_LONG __Pyx_PyInt_AsSignedLongLong(PyObject* x) { + const signed PY_LONG_LONG neg_one = (signed PY_LONG_LONG)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to signed PY_LONG_LONG"); + return (signed PY_LONG_LONG)-1; + } + return (signed PY_LONG_LONG)val; + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(signed PY_LONG_LONG)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return (signed PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + if (unlikely(Py_SIZE(x) < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to signed PY_LONG_LONG"); + return (signed PY_LONG_LONG)-1; + } + return (signed PY_LONG_LONG)PyLong_AsUnsignedLongLong(x); + } else { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(signed PY_LONG_LONG)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return +(signed PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + case -1: return -(signed PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + return (signed PY_LONG_LONG)PyLong_AsLongLong(x); + } + } else { + signed PY_LONG_LONG val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (signed PY_LONG_LONG)-1; + val = __Pyx_PyInt_AsSignedLongLong(tmp); + Py_DECREF(tmp); + return val; + } +} + +static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + #if PY_VERSION_HEX < 0x02050000 + return PyErr_Warn(NULL, message); + #else + return PyErr_WarnEx(NULL, message, 1); + #endif + } + return 0; +} + +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = (start + end) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, /*int argcount,*/ + 0, /*int kwonlyargcount,*/ + 0, /*int nlocals,*/ + 0, /*int stacksize,*/ + 0, /*int flags,*/ + __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, /*int firstlineno,*/ + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_globals = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_globals = PyModule_GetDict(__pyx_m); + if (!py_globals) goto bad; + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + py_globals, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + py_frame->f_lineno = py_line; + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else /* Python 3+ has unicode identifiers */ + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif /*__PYX_DEFAULT_STRING_ENCODING_IS_ASCII*/ + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else /* PY_VERSION_HEX < 0x03030000 */ + if (PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_DATA_SIZE(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII */ + return PyUnicode_AsUTF8AndSize(o, length); +#endif /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII */ +#endif /* PY_VERSION_HEX < 0x03030000 */ + } else +#endif /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT */ + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (r < 0) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { + PyNumberMethods *m; + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return Py_INCREF(x), x; + m = Py_TYPE(x)->tp_as_number; +#if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } +#else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%s__ returned non-%s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + 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 = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { +#if PY_VERSION_HEX < 0x02050000 + if (ival <= LONG_MAX) + return PyInt_FromLong((long)ival); + else { + unsigned char *bytes = (unsigned char *) &ival; + int one = 1; int little = (int)*(unsigned char*)&one; + return _PyLong_FromByteArray(bytes, sizeof(size_t), little, 0); + } +#else + return PyInt_FromSize_t(ival); +#endif +} +static CYTHON_INLINE size_t __Pyx_PyInt_AsSize_t(PyObject* x) { + unsigned PY_LONG_LONG val = __Pyx_PyInt_AsUnsignedLongLong(x); + if (unlikely(val != (unsigned PY_LONG_LONG)(size_t)val)) { + if ((val != (unsigned PY_LONG_LONG)-1) || !PyErr_Occurred()) + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to size_t"); + return (size_t)-1; + } + return (size_t)val; +} + + +#endif /* Py_PYTHON_H */ diff --git a/pyx/tictoc_0.pyx b/pyx/tictoc_0.pyx new file mode 100644 index 0000000..afbae0e --- /dev/null +++ b/pyx/tictoc_0.pyx @@ -0,0 +1,8 @@ +import time + +tic = time.time() + +for i in range(0,10000000): + b=i + +print time.time()-tic diff --git a/pyx/tictoc_0.so b/pyx/tictoc_0.so new file mode 100755 index 0000000000000000000000000000000000000000..d39505c882b4079790515b20ed0b413c606405dd GIT binary patch literal 56324 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 literal 0 HcmV?d00001 diff --git a/pyx/tictoc_1.c b/pyx/tictoc_1.c new file mode 100644 index 0000000..c109209 --- /dev/null +++ b/pyx/tictoc_1.c @@ -0,0 +1,2228 @@ +/* Generated by Cython 0.19.1 on Thu Oct 16 08:52:06 2014 */ + +#define PY_SSIZE_T_CLEAN +#ifndef CYTHON_USE_PYLONG_INTERNALS +#ifdef PYLONG_BITS_IN_DIGIT +#define CYTHON_USE_PYLONG_INTERNALS 0 +#else +#include "pyconfig.h" +#ifdef PYLONG_BITS_IN_DIGIT +#define CYTHON_USE_PYLONG_INTERNALS 1 +#else +#define CYTHON_USE_PYLONG_INTERNALS 0 +#endif +#endif +#endif +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02040000 + #error Cython requires Python 2.4+. +#else +#include /* For offsetof */ +#ifndef offsetof +#define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION +#define CYTHON_COMPILING_IN_PYPY 1 +#define CYTHON_COMPILING_IN_CPYTHON 0 +#else +#define CYTHON_COMPILING_IN_PYPY 0 +#define CYTHON_COMPILING_IN_CPYTHON 1 +#endif +#if PY_VERSION_HEX < 0x02050000 + typedef int Py_ssize_t; + #define PY_SSIZE_T_MAX INT_MAX + #define PY_SSIZE_T_MIN INT_MIN + #define PY_FORMAT_SIZE_T "" + #define CYTHON_FORMAT_SSIZE_T "" + #define PyInt_FromSsize_t(z) PyInt_FromLong(z) + #define PyInt_AsSsize_t(o) __Pyx_PyInt_AsInt(o) + #define PyNumber_Index(o) ((PyNumber_Check(o) && !PyFloat_Check(o)) ? PyNumber_Int(o) : \ + (PyErr_Format(PyExc_TypeError, \ + "expected index value, got %.200s", Py_TYPE(o)->tp_name), \ + (PyObject*)0)) + #define __Pyx_PyIndex_Check(o) (PyNumber_Check(o) && !PyFloat_Check(o) && \ + !PyComplex_Check(o)) + #define PyIndex_Check __Pyx_PyIndex_Check + #define PyErr_WarnEx(category, message, stacklevel) PyErr_Warn(category, message) + #define __PYX_BUILD_PY_SSIZE_T "i" +#else + #define __PYX_BUILD_PY_SSIZE_T "n" + #define CYTHON_FORMAT_SSIZE_T "z" + #define __Pyx_PyIndex_Check PyIndex_Check +#endif +#if PY_VERSION_HEX < 0x02060000 + #define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt) + #define Py_TYPE(ob) (((PyObject*)(ob))->ob_type) + #define Py_SIZE(ob) (((PyVarObject*)(ob))->ob_size) + #define PyVarObject_HEAD_INIT(type, size) \ + PyObject_HEAD_INIT(type) size, + #define PyType_Modified(t) + typedef struct { + void *buf; + PyObject *obj; + Py_ssize_t len; + Py_ssize_t itemsize; + int readonly; + int ndim; + char *format; + Py_ssize_t *shape; + Py_ssize_t *strides; + Py_ssize_t *suboffsets; + void *internal; + } Py_buffer; + #define PyBUF_SIMPLE 0 + #define PyBUF_WRITABLE 0x0001 + #define PyBUF_FORMAT 0x0004 + #define PyBUF_ND 0x0008 + #define PyBUF_STRIDES (0x0010 | PyBUF_ND) + #define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES) + #define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES) + #define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES) + #define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES) + #define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_FORMAT | PyBUF_WRITABLE) + #define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_FORMAT | PyBUF_WRITABLE) + typedef int (*getbufferproc)(PyObject *, Py_buffer *, int); + typedef void (*releasebufferproc)(PyObject *, Py_buffer *); +#endif +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ + PyCode_New(a, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif +#if PY_MAJOR_VERSION < 3 && PY_MINOR_VERSION < 6 + #define PyUnicode_FromString(s) PyUnicode_Decode(s, strlen(s), "UTF-8", "strict") +#endif +#if PY_MAJOR_VERSION >= 3 + #define Py_TPFLAGS_CHECKTYPES 0 + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#if (PY_VERSION_HEX < 0x02060000) || (PY_MAJOR_VERSION >= 3) + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#if PY_VERSION_HEX < 0x02060000 + #define Py_TPFLAGS_HAVE_VERSION_TAG 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ? \ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) +#else + #define CYTHON_PEP393_ENABLED 0 + #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_READ(k, d, i) ((k=k), (Py_UCS4)(((Py_UNICODE*)d)[i])) +#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 +#endif +#if PY_VERSION_HEX < 0x02060000 + #define PyBytesObject PyStringObject + #define PyBytes_Type PyString_Type + #define PyBytes_Check PyString_Check + #define PyBytes_CheckExact PyString_CheckExact + #define PyBytes_FromString PyString_FromString + #define PyBytes_FromStringAndSize PyString_FromStringAndSize + #define PyBytes_FromFormat PyString_FromFormat + #define PyBytes_DecodeEscape PyString_DecodeEscape + #define PyBytes_AsString PyString_AsString + #define PyBytes_AsStringAndSize PyString_AsStringAndSize + #define PyBytes_Size PyString_Size + #define PyBytes_AS_STRING PyString_AS_STRING + #define PyBytes_GET_SIZE PyString_GET_SIZE + #define PyBytes_Repr PyString_Repr + #define PyBytes_Concat PyString_Concat + #define PyBytes_ConcatAndDel PyString_ConcatAndDel +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj) || \ + PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (Py_TYPE(obj) == &PyBaseString_Type) +#endif +#if PY_VERSION_HEX < 0x02060000 + #define PySet_Check(obj) PyObject_TypeCheck(obj, &PySet_Type) + #define PyFrozenSet_Check(obj) PyObject_TypeCheck(obj, &PyFrozenSet_Type) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_VERSION_HEX < 0x03020000 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if (PY_MAJOR_VERSION < 3) || (PY_VERSION_HEX >= 0x03010300) + #define __Pyx_PySequence_GetSlice(obj, a, b) PySequence_GetSlice(obj, a, b) + #define __Pyx_PySequence_SetSlice(obj, a, b, value) PySequence_SetSlice(obj, a, b, value) + #define __Pyx_PySequence_DelSlice(obj, a, b) PySequence_DelSlice(obj, a, b) +#else + #define __Pyx_PySequence_GetSlice(obj, a, b) (unlikely(!(obj)) ? \ + (PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), (PyObject*)0) : \ + (likely((obj)->ob_type->tp_as_mapping) ? (PySequence_GetSlice(obj, a, b)) : \ + (PyErr_Format(PyExc_TypeError, "'%.200s' object is unsliceable", (obj)->ob_type->tp_name), (PyObject*)0))) + #define __Pyx_PySequence_SetSlice(obj, a, b, value) (unlikely(!(obj)) ? \ + (PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), -1) : \ + (likely((obj)->ob_type->tp_as_mapping) ? (PySequence_SetSlice(obj, a, b, value)) : \ + (PyErr_Format(PyExc_TypeError, "'%.200s' object doesn't support slice assignment", (obj)->ob_type->tp_name), -1))) + #define __Pyx_PySequence_DelSlice(obj, a, b) (unlikely(!(obj)) ? \ + (PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), -1) : \ + (likely((obj)->ob_type->tp_as_mapping) ? (PySequence_DelSlice(obj, a, b)) : \ + (PyErr_Format(PyExc_TypeError, "'%.200s' object doesn't support slice deletion", (obj)->ob_type->tp_name), -1))) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#endif +#if PY_VERSION_HEX < 0x02050000 + #define __Pyx_GetAttrString(o,n) PyObject_GetAttrString((o),((char *)(n))) + #define __Pyx_SetAttrString(o,n,a) PyObject_SetAttrString((o),((char *)(n)),(a)) + #define __Pyx_DelAttrString(o,n) PyObject_DelAttrString((o),((char *)(n))) +#else + #define __Pyx_GetAttrString(o,n) PyObject_GetAttrString((o),(n)) + #define __Pyx_SetAttrString(o,n,a) PyObject_SetAttrString((o),(n),(a)) + #define __Pyx_DelAttrString(o,n) PyObject_DelAttrString((o),(n)) +#endif +#if PY_VERSION_HEX < 0x02050000 + #define __Pyx_NAMESTR(n) ((char *)(n)) + #define __Pyx_DOCSTR(n) ((char *)(n)) +#else + #define __Pyx_NAMESTR(n) (n) + #define __Pyx_DOCSTR(n) (n) +#endif +#ifndef CYTHON_INLINE + #if 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 +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + /* Initialize NaN. The sign is irrelevant, an exponent with all bits 1 and + a nonzero mantissa means NaN. If the first bit in the mantissa is 1, it is + a quiet NaN. */ + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif + + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) +#define _USE_MATH_DEFINES +#endif +#include +#define __PYX_HAVE__tictoc_1 +#define __PYX_HAVE_API__tictoc_1 +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; /*proto*/ + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(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_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromUString(s) __Pyx_PyObject_FromString((char*)s) +#define __Pyx_PyBytes_FromUString(s) __Pyx_PyBytes_FromString((char*)s) +#define __Pyx_PyStr_FromUString(s) __Pyx_PyStr_FromString((char*)s) +#define __Pyx_PyUnicode_FromUString(s) __Pyx_PyUnicode_FromString((char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return u_end - u - 1; +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_Owned_Py_None(b) (Py_INCREF(Py_None), Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? (Py_INCREF(Py_True), Py_True) : (Py_INCREF(Py_False), Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +static CYTHON_INLINE size_t __Pyx_PyInt_AsSize_t(PyObject*); +#if CYTHON_COMPILING_IN_CPYTHON +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params() { + PyObject* sys = NULL; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + sys = PyImport_ImportModule("sys"); + if (sys == NULL) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + if (default_encoding == NULL) goto bad; + if (strcmp(PyBytes_AsString(default_encoding), "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + const char* default_encoding_c = PyBytes_AS_STRING(default_encoding); + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (ascii_chars_u == NULL) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (ascii_chars_b == NULL || strncmp(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 '%s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + } + Py_XDECREF(sys); + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return 0; +bad: + Py_XDECREF(sys); + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params() { + PyObject* sys = NULL; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (sys == NULL) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + if (default_encoding == NULL) goto bad; + default_encoding_c = PyBytes_AS_STRING(default_encoding); + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(sys); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(sys); + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +#ifdef __GNUC__ + /* Test for GCC > 2.95 */ + #if __GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) + #else /* __GNUC__ > 2 ... */ + #define likely(x) (x) + #define unlikely(x) (x) + #endif /* __GNUC__ > 2 ... */ +#else /* __GNUC__ */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "tictoc_1.pyx", +}; + +/*--- Type declarations ---*/ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); /*proto*/ + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil) \ + if (acquire_gil) { \ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ + PyGILState_Release(__pyx_gilstate_save); \ + } else { \ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil) \ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext() \ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif /* CYTHON_REFNANNY */ +#define __Pyx_XDECREF_SET(r, v) do { \ + PyObject *tmp = (PyObject *) r; \ + r = v; __Pyx_XDECREF(tmp); \ + } while (0) +#define __Pyx_DECREF_SET(r, v) do { \ + PyObject *tmp = (PyObject *) r; \ + r = v; __Pyx_DECREF(tmp); \ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +static PyObject *__Pyx_GetBuiltinName(PyObject *name); /*proto*/ + +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); /*proto*/ + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /*proto*/ + +static int __Pyx_Print(PyObject*, PyObject *, int); /*proto*/ +#if CYTHON_COMPILING_IN_PYPY || PY_MAJOR_VERSION >= 3 +static PyObject* __pyx_print = 0; +static PyObject* __pyx_print_kwargs = 0; +#endif + +static int __Pyx_PrintOne(PyObject* stream, PyObject *o); /*proto*/ + +static CYTHON_INLINE unsigned char __Pyx_PyInt_AsUnsignedChar(PyObject *); + +static CYTHON_INLINE unsigned short __Pyx_PyInt_AsUnsignedShort(PyObject *); + +static CYTHON_INLINE unsigned int __Pyx_PyInt_AsUnsignedInt(PyObject *); + +static CYTHON_INLINE char __Pyx_PyInt_AsChar(PyObject *); + +static CYTHON_INLINE short __Pyx_PyInt_AsShort(PyObject *); + +static CYTHON_INLINE int __Pyx_PyInt_AsInt(PyObject *); + +static CYTHON_INLINE signed char __Pyx_PyInt_AsSignedChar(PyObject *); + +static CYTHON_INLINE signed short __Pyx_PyInt_AsSignedShort(PyObject *); + +static CYTHON_INLINE signed int __Pyx_PyInt_AsSignedInt(PyObject *); + +static CYTHON_INLINE int __Pyx_PyInt_AsLongDouble(PyObject *); + +static CYTHON_INLINE unsigned long __Pyx_PyInt_AsUnsignedLong(PyObject *); + +static CYTHON_INLINE unsigned PY_LONG_LONG __Pyx_PyInt_AsUnsignedLongLong(PyObject *); + +static CYTHON_INLINE long __Pyx_PyInt_AsLong(PyObject *); + +static CYTHON_INLINE PY_LONG_LONG __Pyx_PyInt_AsLongLong(PyObject *); + +static CYTHON_INLINE signed long __Pyx_PyInt_AsSignedLong(PyObject *); + +static CYTHON_INLINE signed PY_LONG_LONG __Pyx_PyInt_AsSignedLongLong(PyObject *); + +static int __Pyx_check_binary_version(void); + +typedef struct { + int code_line; + PyCodeObject* code_object; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); /*proto*/ + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /*proto*/ + + +/* Module declarations from 'tictoc_1' */ +#define __Pyx_MODULE_NAME "tictoc_1" +int __pyx_module_is_main_tictoc_1 = 0; + +/* Implementation of 'tictoc_1' */ +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_pf_8tictoc_1_test(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static char __pyx_k_3[] = "/home/momo/dev/python/profiling/pyx/tictoc_1.pyx"; +static char __pyx_k__b[] = "b"; +static char __pyx_k__i[] = "i"; +static char __pyx_k__cos[] = "cos"; +static char __pyx_k__end[] = "end"; +static char __pyx_k__tic[] = "tic"; +static char __pyx_k__toc[] = "toc"; +static char __pyx_k__file[] = "file"; +static char __pyx_k__math[] = "math"; +static char __pyx_k__test[] = "test"; +static char __pyx_k__time[] = "time"; +static char __pyx_k__print[] = "print"; +static char __pyx_k__range[] = "range"; +static char __pyx_k____main__[] = "__main__"; +static char __pyx_k____test__[] = "__test__"; +static char __pyx_k__tictoc_1[] = "tictoc_1"; +static char __pyx_k____import__[] = "__import__"; +static PyObject *__pyx_kp_s_3; +static PyObject *__pyx_n_s____import__; +static PyObject *__pyx_n_s____main__; +static PyObject *__pyx_n_s____test__; +static PyObject *__pyx_n_s__b; +static PyObject *__pyx_n_s__cos; +static PyObject *__pyx_n_s__end; +static PyObject *__pyx_n_s__file; +static PyObject *__pyx_n_s__i; +static PyObject *__pyx_n_s__math; +static PyObject *__pyx_n_s__print; +static PyObject *__pyx_n_s__range; +static PyObject *__pyx_n_s__test; +static PyObject *__pyx_n_s__tic; +static PyObject *__pyx_n_s__tictoc_1; +static PyObject *__pyx_n_s__time; +static PyObject *__pyx_n_s__toc; +static PyObject *__pyx_k_tuple_1; +static PyObject *__pyx_k_codeobj_2; + +/* Python wrapper */ +static PyObject *__pyx_pw_8tictoc_1_1test(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyMethodDef __pyx_mdef_8tictoc_1_1test = {__Pyx_NAMESTR("test"), (PyCFunction)__pyx_pw_8tictoc_1_1test, METH_NOARGS, __Pyx_DOCSTR(0)}; +static PyObject *__pyx_pw_8tictoc_1_1test(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("test (wrapper)", 0); + __pyx_r = __pyx_pf_8tictoc_1_test(__pyx_self); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "tictoc_1.pyx":4 + * import math + * + * def test(): # <<<<<<<<<<<<<< + * for i in range(0,1000000000): + * b=math.cos(i) + */ + +static PyObject *__pyx_pf_8tictoc_1_test(CYTHON_UNUSED PyObject *__pyx_self) { + long __pyx_v_i; + CYTHON_UNUSED PyObject *__pyx_v_b = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + long __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("test", 0); + + /* "tictoc_1.pyx":5 + * + * def test(): + * for i in range(0,1000000000): # <<<<<<<<<<<<<< + * b=math.cos(i) + * + */ + for (__pyx_t_1 = 0; __pyx_t_1 < 1000000000; __pyx_t_1+=1) { + __pyx_v_i = __pyx_t_1; + + /* "tictoc_1.pyx":6 + * def test(): + * for i in range(0,1000000000): + * b=math.cos(i) # <<<<<<<<<<<<<< + * + * tic = time.time() + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s__math); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 6; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s__cos); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 6; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyInt_FromLong(__pyx_v_i); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 6; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 6; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = PyObject_Call(__pyx_t_3, ((PyObject *)__pyx_t_4), NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 6; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(((PyObject *)__pyx_t_4)); __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_b, __pyx_t_2); + __pyx_t_2 = 0; + } + + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("tictoc_1.test", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_b); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + __Pyx_NAMESTR("tictoc_1"), + 0, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_s_3, __pyx_k_3, sizeof(__pyx_k_3), 0, 0, 1, 0}, + {&__pyx_n_s____import__, __pyx_k____import__, sizeof(__pyx_k____import__), 0, 0, 1, 1}, + {&__pyx_n_s____main__, __pyx_k____main__, sizeof(__pyx_k____main__), 0, 0, 1, 1}, + {&__pyx_n_s____test__, __pyx_k____test__, sizeof(__pyx_k____test__), 0, 0, 1, 1}, + {&__pyx_n_s__b, __pyx_k__b, sizeof(__pyx_k__b), 0, 0, 1, 1}, + {&__pyx_n_s__cos, __pyx_k__cos, sizeof(__pyx_k__cos), 0, 0, 1, 1}, + {&__pyx_n_s__end, __pyx_k__end, sizeof(__pyx_k__end), 0, 0, 1, 1}, + {&__pyx_n_s__file, __pyx_k__file, sizeof(__pyx_k__file), 0, 0, 1, 1}, + {&__pyx_n_s__i, __pyx_k__i, sizeof(__pyx_k__i), 0, 0, 1, 1}, + {&__pyx_n_s__math, __pyx_k__math, sizeof(__pyx_k__math), 0, 0, 1, 1}, + {&__pyx_n_s__print, __pyx_k__print, sizeof(__pyx_k__print), 0, 0, 1, 1}, + {&__pyx_n_s__range, __pyx_k__range, sizeof(__pyx_k__range), 0, 0, 1, 1}, + {&__pyx_n_s__test, __pyx_k__test, sizeof(__pyx_k__test), 0, 0, 1, 1}, + {&__pyx_n_s__tic, __pyx_k__tic, sizeof(__pyx_k__tic), 0, 0, 1, 1}, + {&__pyx_n_s__tictoc_1, __pyx_k__tictoc_1, sizeof(__pyx_k__tictoc_1), 0, 0, 1, 1}, + {&__pyx_n_s__time, __pyx_k__time, sizeof(__pyx_k__time), 0, 0, 1, 1}, + {&__pyx_n_s__toc, __pyx_k__toc, sizeof(__pyx_k__toc), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s__range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "tictoc_1.pyx":4 + * import math + * + * def test(): # <<<<<<<<<<<<<< + * for i in range(0,1000000000): + * b=math.cos(i) + */ + __pyx_k_tuple_1 = PyTuple_Pack(2, ((PyObject *)__pyx_n_s__i), ((PyObject *)__pyx_n_s__b)); if (unlikely(!__pyx_k_tuple_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_k_tuple_1); + __Pyx_GIVEREF(((PyObject *)__pyx_k_tuple_1)); + __pyx_k_codeobj_2 = (PyObject*)__Pyx_PyCode_New(0, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_k_tuple_1, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_3, __pyx_n_s__test, 4, __pyx_empty_bytes); if (unlikely(!__pyx_k_codeobj_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC inittictoc_1(void); /*proto*/ +PyMODINIT_FUNC inittictoc_1(void) +#else +PyMODINIT_FUNC PyInit_tictoc_1(void); /*proto*/ +PyMODINIT_FUNC PyInit_tictoc_1(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #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("PyMODINIT_FUNC PyInit_tictoc_1(void)", 0); + if ( __Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #ifdef __Pyx_CyFunction_USED + if (__Pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4(__Pyx_NAMESTR("tictoc_1"), __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + Py_INCREF(__pyx_d); + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!PyDict_GetItemString(modules, "tictoc_1")) { + if (unlikely(PyDict_SetItemString(modules, "tictoc_1", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + __pyx_b = PyImport_AddModule(__Pyx_NAMESTR(__Pyx_BUILTIN_MODULE_NAME)); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (__Pyx_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + /*--- Initialize various global constants etc. ---*/ + if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __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_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + if (__pyx_module_is_main_tictoc_1) { + if (__Pyx_SetAttrString(__pyx_m, "__name__", __pyx_n_s____main__) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + } + /*--- Builtin init code ---*/ + if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Constants init code ---*/ + if (unlikely(__Pyx_InitCachedConstants() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + /*--- Type init code ---*/ + /*--- Type import code ---*/ + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + /*--- Execution code ---*/ + + /* "tictoc_1.pyx":1 + * import time # <<<<<<<<<<<<<< + * import math + * + */ + __pyx_t_1 = __Pyx_Import(((PyObject *)__pyx_n_s__time), 0, -1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s__time, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "tictoc_1.pyx":2 + * import time + * import math # <<<<<<<<<<<<<< + * + * def test(): + */ + __pyx_t_1 = __Pyx_Import(((PyObject *)__pyx_n_s__math), 0, -1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s__math, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "tictoc_1.pyx":4 + * import math + * + * def test(): # <<<<<<<<<<<<<< + * for i in range(0,1000000000): + * b=math.cos(i) + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_8tictoc_1_1test, NULL, __pyx_n_s__tictoc_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s__test, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "tictoc_1.pyx":8 + * b=math.cos(i) + * + * tic = time.time() # <<<<<<<<<<<<<< + * test() + * toc = time.time()-tic + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s__time); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s__time); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_Call(__pyx_t_2, ((PyObject *)__pyx_empty_tuple), NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s__tic, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "tictoc_1.pyx":9 + * + * tic = time.time() + * test() # <<<<<<<<<<<<<< + * toc = time.time()-tic + * print toc + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s__test); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 9; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Call(__pyx_t_1, ((PyObject *)__pyx_empty_tuple), NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 9; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "tictoc_1.pyx":10 + * tic = time.time() + * test() + * toc = time.time()-tic # <<<<<<<<<<<<<< + * print toc + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s__time); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s__time); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_Call(__pyx_t_1, ((PyObject *)__pyx_empty_tuple), NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s__tic); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyNumber_Subtract(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s__toc, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "tictoc_1.pyx":11 + * test() + * toc = time.time()-tic + * print toc # <<<<<<<<<<<<<< + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s__toc); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 11; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_PrintOne(0, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 11; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "tictoc_1.pyx":1 + * import time # <<<<<<<<<<<<<< + * import math + * + */ + __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(((PyObject *)__pyx_t_3)); + if (PyDict_SetItem(__pyx_d, __pyx_n_s____test__, ((PyObject *)__pyx_t_3)) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(((PyObject *)__pyx_t_3)); __pyx_t_3 = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + if (__pyx_m) { + __Pyx_AddTraceback("init tictoc_1", __pyx_clineno, __pyx_lineno, __pyx_filename); + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init tictoc_1"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* Runtime support code */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif /* CYTHON_REFNANNY */ + +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if CYTHON_COMPILING_IN_CPYTHON + result = PyDict_GetItem(__pyx_d, name); + if (result) { + Py_INCREF(result); + } else { +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s____import__); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + #if PY_VERSION_HEX >= 0x02050000 + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; /* try absolute import on failure */ + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } + #else + if (level>0) { + PyErr_SetString(PyExc_RuntimeError, "Relative import is not supported for Python <=2.4."); + goto bad; + } + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, NULL); + #endif +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +#if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION < 3 +static PyObject *__Pyx_GetStdout(void) { + PyObject *f = PySys_GetObject((char *)"stdout"); + if (!f) { + PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout"); + } + return f; +} +static int __Pyx_Print(PyObject* f, PyObject *arg_tuple, int newline) { + int i; + if (!f) { + if (!(f = __Pyx_GetStdout())) + return -1; + } + Py_INCREF(f); + for (i=0; i < PyTuple_GET_SIZE(arg_tuple); i++) { + PyObject* v; + if (PyFile_SoftSpace(f, 1)) { + if (PyFile_WriteString(" ", f) < 0) + goto error; + } + v = PyTuple_GET_ITEM(arg_tuple, i); + if (PyFile_WriteObject(v, f, Py_PRINT_RAW) < 0) + goto error; + if (PyString_Check(v)) { + char *s = PyString_AsString(v); + Py_ssize_t len = PyString_Size(v); + if (len > 0 && + isspace(Py_CHARMASK(s[len-1])) && + s[len-1] != ' ') + PyFile_SoftSpace(f, 0); + } + } + if (newline) { + if (PyFile_WriteString("\n", f) < 0) + goto error; + PyFile_SoftSpace(f, 0); + } + Py_DECREF(f); + return 0; +error: + Py_DECREF(f); + return -1; +} +#else /* Python 3 has a print function */ +static int __Pyx_Print(PyObject* stream, PyObject *arg_tuple, int newline) { + PyObject* kwargs = 0; + PyObject* result = 0; + PyObject* end_string; + if (unlikely(!__pyx_print)) { + __pyx_print = PyObject_GetAttr(__pyx_b, __pyx_n_s__print); + if (!__pyx_print) + return -1; + } + if (stream) { + kwargs = PyDict_New(); + if (unlikely(!kwargs)) + return -1; + if (unlikely(PyDict_SetItem(kwargs, __pyx_n_s__file, stream) < 0)) + goto bad; + if (!newline) { + end_string = PyUnicode_FromStringAndSize(" ", 1); + if (unlikely(!end_string)) + goto bad; + if (PyDict_SetItem(kwargs, __pyx_n_s__end, end_string) < 0) { + Py_DECREF(end_string); + goto bad; + } + Py_DECREF(end_string); + } + } else if (!newline) { + if (unlikely(!__pyx_print_kwargs)) { + __pyx_print_kwargs = PyDict_New(); + if (unlikely(!__pyx_print_kwargs)) + return -1; + end_string = PyUnicode_FromStringAndSize(" ", 1); + if (unlikely(!end_string)) + return -1; + if (PyDict_SetItem(__pyx_print_kwargs, __pyx_n_s__end, end_string) < 0) { + Py_DECREF(end_string); + return -1; + } + Py_DECREF(end_string); + } + kwargs = __pyx_print_kwargs; + } + result = PyObject_Call(__pyx_print, arg_tuple, kwargs); + if (unlikely(kwargs) && (kwargs != __pyx_print_kwargs)) + Py_DECREF(kwargs); + if (!result) + return -1; + Py_DECREF(result); + return 0; +bad: + if (kwargs != __pyx_print_kwargs) + Py_XDECREF(kwargs); + return -1; +} +#endif + +#if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION < 3 +static int __Pyx_PrintOne(PyObject* f, PyObject *o) { + if (!f) { + if (!(f = __Pyx_GetStdout())) + return -1; + } + Py_INCREF(f); + if (PyFile_SoftSpace(f, 0)) { + if (PyFile_WriteString(" ", f) < 0) + goto error; + } + if (PyFile_WriteObject(o, f, Py_PRINT_RAW) < 0) + goto error; + if (PyFile_WriteString("\n", f) < 0) + goto error; + Py_DECREF(f); + return 0; +error: + Py_DECREF(f); + return -1; + /* the line below is just to avoid C compiler + * warnings about unused functions */ + return __Pyx_Print(f, NULL, 0); +} +#else /* Python 3 has a print function */ +static int __Pyx_PrintOne(PyObject* stream, PyObject *o) { + int res; + PyObject* arg_tuple = PyTuple_Pack(1, o); + if (unlikely(!arg_tuple)) + return -1; + res = __Pyx_Print(stream, arg_tuple, 1); + Py_DECREF(arg_tuple); + return res; +} +#endif + +static CYTHON_INLINE unsigned char __Pyx_PyInt_AsUnsignedChar(PyObject* x) { + const unsigned char neg_one = (unsigned char)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(unsigned char) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(unsigned char)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to unsigned char" : + "value too large to convert to unsigned char"); + } + return (unsigned char)-1; + } + return (unsigned char)val; + } + return (unsigned char)__Pyx_PyInt_AsUnsignedLong(x); +} + +static CYTHON_INLINE unsigned short __Pyx_PyInt_AsUnsignedShort(PyObject* x) { + const unsigned short neg_one = (unsigned short)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(unsigned short) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(unsigned short)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to unsigned short" : + "value too large to convert to unsigned short"); + } + return (unsigned short)-1; + } + return (unsigned short)val; + } + return (unsigned short)__Pyx_PyInt_AsUnsignedLong(x); +} + +static CYTHON_INLINE unsigned int __Pyx_PyInt_AsUnsignedInt(PyObject* x) { + const unsigned int neg_one = (unsigned int)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(unsigned int) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(unsigned int)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to unsigned int" : + "value too large to convert to unsigned int"); + } + return (unsigned int)-1; + } + return (unsigned int)val; + } + return (unsigned int)__Pyx_PyInt_AsUnsignedLong(x); +} + +static CYTHON_INLINE char __Pyx_PyInt_AsChar(PyObject* x) { + const char neg_one = (char)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(char) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(char)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to char" : + "value too large to convert to char"); + } + return (char)-1; + } + return (char)val; + } + return (char)__Pyx_PyInt_AsLong(x); +} + +static CYTHON_INLINE short __Pyx_PyInt_AsShort(PyObject* x) { + const short neg_one = (short)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(short) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(short)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to short" : + "value too large to convert to short"); + } + return (short)-1; + } + return (short)val; + } + return (short)__Pyx_PyInt_AsLong(x); +} + +static CYTHON_INLINE int __Pyx_PyInt_AsInt(PyObject* x) { + const int neg_one = (int)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(int) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(int)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to int" : + "value too large to convert to int"); + } + return (int)-1; + } + return (int)val; + } + return (int)__Pyx_PyInt_AsLong(x); +} + +static CYTHON_INLINE signed char __Pyx_PyInt_AsSignedChar(PyObject* x) { + const signed char neg_one = (signed char)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(signed char) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(signed char)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to signed char" : + "value too large to convert to signed char"); + } + return (signed char)-1; + } + return (signed char)val; + } + return (signed char)__Pyx_PyInt_AsSignedLong(x); +} + +static CYTHON_INLINE signed short __Pyx_PyInt_AsSignedShort(PyObject* x) { + const signed short neg_one = (signed short)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(signed short) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(signed short)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to signed short" : + "value too large to convert to signed short"); + } + return (signed short)-1; + } + return (signed short)val; + } + return (signed short)__Pyx_PyInt_AsSignedLong(x); +} + +static CYTHON_INLINE signed int __Pyx_PyInt_AsSignedInt(PyObject* x) { + const signed int neg_one = (signed int)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(signed int) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(signed int)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to signed int" : + "value too large to convert to signed int"); + } + return (signed int)-1; + } + return (signed int)val; + } + return (signed int)__Pyx_PyInt_AsSignedLong(x); +} + +static CYTHON_INLINE int __Pyx_PyInt_AsLongDouble(PyObject* x) { + const int neg_one = (int)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; + if (sizeof(int) < sizeof(long)) { + long val = __Pyx_PyInt_AsLong(x); + if (unlikely(val != (long)(int)val)) { + if (!unlikely(val == -1 && PyErr_Occurred())) { + PyErr_SetString(PyExc_OverflowError, + (is_unsigned && unlikely(val < 0)) ? + "can't convert negative value to int" : + "value too large to convert to int"); + } + return (int)-1; + } + return (int)val; + } + return (int)__Pyx_PyInt_AsLong(x); +} + +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS +#include "longintrepr.h" +#endif +#endif +static CYTHON_INLINE unsigned long __Pyx_PyInt_AsUnsignedLong(PyObject* x) { + const unsigned long neg_one = (unsigned long)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned long"); + return (unsigned long)-1; + } + return (unsigned long)val; + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(unsigned long)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return (unsigned long) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + if (unlikely(Py_SIZE(x) < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned long"); + return (unsigned long)-1; + } + return (unsigned long)PyLong_AsUnsignedLong(x); + } else { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(unsigned long)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return +(unsigned long) ((PyLongObject*)x)->ob_digit[0]; + case -1: return -(unsigned long) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + return (unsigned long)PyLong_AsLong(x); + } + } else { + unsigned long val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (unsigned long)-1; + val = __Pyx_PyInt_AsUnsignedLong(tmp); + Py_DECREF(tmp); + return val; + } +} + +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS +#include "longintrepr.h" +#endif +#endif +static CYTHON_INLINE unsigned PY_LONG_LONG __Pyx_PyInt_AsUnsignedLongLong(PyObject* x) { + const unsigned PY_LONG_LONG neg_one = (unsigned PY_LONG_LONG)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned PY_LONG_LONG"); + return (unsigned PY_LONG_LONG)-1; + } + return (unsigned PY_LONG_LONG)val; + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(unsigned PY_LONG_LONG)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return (unsigned PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + if (unlikely(Py_SIZE(x) < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned PY_LONG_LONG"); + return (unsigned PY_LONG_LONG)-1; + } + return (unsigned PY_LONG_LONG)PyLong_AsUnsignedLongLong(x); + } else { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(unsigned PY_LONG_LONG)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return +(unsigned PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + case -1: return -(unsigned PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + return (unsigned PY_LONG_LONG)PyLong_AsLongLong(x); + } + } else { + unsigned PY_LONG_LONG val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (unsigned PY_LONG_LONG)-1; + val = __Pyx_PyInt_AsUnsignedLongLong(tmp); + Py_DECREF(tmp); + return val; + } +} + +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS +#include "longintrepr.h" +#endif +#endif +static CYTHON_INLINE long __Pyx_PyInt_AsLong(PyObject* x) { + const long neg_one = (long)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long)-1; + } + return (long)val; + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(long)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return (long) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + if (unlikely(Py_SIZE(x) < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long)-1; + } + return (long)PyLong_AsUnsignedLong(x); + } else { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(long)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return +(long) ((PyLongObject*)x)->ob_digit[0]; + case -1: return -(long) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + return (long)PyLong_AsLong(x); + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (long)-1; + val = __Pyx_PyInt_AsLong(tmp); + Py_DECREF(tmp); + return val; + } +} + +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS +#include "longintrepr.h" +#endif +#endif +static CYTHON_INLINE PY_LONG_LONG __Pyx_PyInt_AsLongLong(PyObject* x) { + const PY_LONG_LONG neg_one = (PY_LONG_LONG)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to PY_LONG_LONG"); + return (PY_LONG_LONG)-1; + } + return (PY_LONG_LONG)val; + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(PY_LONG_LONG)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return (PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + if (unlikely(Py_SIZE(x) < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to PY_LONG_LONG"); + return (PY_LONG_LONG)-1; + } + return (PY_LONG_LONG)PyLong_AsUnsignedLongLong(x); + } else { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(PY_LONG_LONG)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return +(PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + case -1: return -(PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + return (PY_LONG_LONG)PyLong_AsLongLong(x); + } + } else { + PY_LONG_LONG val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (PY_LONG_LONG)-1; + val = __Pyx_PyInt_AsLongLong(tmp); + Py_DECREF(tmp); + return val; + } +} + +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS +#include "longintrepr.h" +#endif +#endif +static CYTHON_INLINE signed long __Pyx_PyInt_AsSignedLong(PyObject* x) { + const signed long neg_one = (signed long)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to signed long"); + return (signed long)-1; + } + return (signed long)val; + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(signed long)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return (signed long) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + if (unlikely(Py_SIZE(x) < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to signed long"); + return (signed long)-1; + } + return (signed long)PyLong_AsUnsignedLong(x); + } else { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(signed long)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return +(signed long) ((PyLongObject*)x)->ob_digit[0]; + case -1: return -(signed long) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + return (signed long)PyLong_AsLong(x); + } + } else { + signed long val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (signed long)-1; + val = __Pyx_PyInt_AsSignedLong(tmp); + Py_DECREF(tmp); + return val; + } +} + +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS +#include "longintrepr.h" +#endif +#endif +static CYTHON_INLINE signed PY_LONG_LONG __Pyx_PyInt_AsSignedLongLong(PyObject* x) { + const signed PY_LONG_LONG neg_one = (signed PY_LONG_LONG)-1, const_zero = 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to signed PY_LONG_LONG"); + return (signed PY_LONG_LONG)-1; + } + return (signed PY_LONG_LONG)val; + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(signed PY_LONG_LONG)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return (signed PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + if (unlikely(Py_SIZE(x) < 0)) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to signed PY_LONG_LONG"); + return (signed PY_LONG_LONG)-1; + } + return (signed PY_LONG_LONG)PyLong_AsUnsignedLongLong(x); + } else { +#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +#if CYTHON_USE_PYLONG_INTERNALS + if (sizeof(digit) <= sizeof(signed PY_LONG_LONG)) { + switch (Py_SIZE(x)) { + case 0: return 0; + case 1: return +(signed PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + case -1: return -(signed PY_LONG_LONG) ((PyLongObject*)x)->ob_digit[0]; + } + } +#endif +#endif + return (signed PY_LONG_LONG)PyLong_AsLongLong(x); + } + } else { + signed PY_LONG_LONG val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (signed PY_LONG_LONG)-1; + val = __Pyx_PyInt_AsSignedLongLong(tmp); + Py_DECREF(tmp); + return val; + } +} + +static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + #if PY_VERSION_HEX < 0x02050000 + return PyErr_Warn(NULL, message); + #else + return PyErr_WarnEx(NULL, message, 1); + #endif + } + return 0; +} + +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = (start + end) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, /*int argcount,*/ + 0, /*int kwonlyargcount,*/ + 0, /*int nlocals,*/ + 0, /*int stacksize,*/ + 0, /*int flags,*/ + __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, /*int firstlineno,*/ + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_globals = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_globals = PyModule_GetDict(__pyx_m); + if (!py_globals) goto bad; + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + py_globals, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + py_frame->f_lineno = py_line; + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else /* Python 3+ has unicode identifiers */ + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif /*__PYX_DEFAULT_STRING_ENCODING_IS_ASCII*/ + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else /* PY_VERSION_HEX < 0x03030000 */ + if (PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_DATA_SIZE(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII */ + return PyUnicode_AsUTF8AndSize(o, length); +#endif /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII */ +#endif /* PY_VERSION_HEX < 0x03030000 */ + } else +#endif /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT */ + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (r < 0) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { + PyNumberMethods *m; + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return Py_INCREF(x), x; + m = Py_TYPE(x)->tp_as_number; +#if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } +#else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%s__ returned non-%s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + 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 = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { +#if PY_VERSION_HEX < 0x02050000 + if (ival <= LONG_MAX) + return PyInt_FromLong((long)ival); + else { + unsigned char *bytes = (unsigned char *) &ival; + int one = 1; int little = (int)*(unsigned char*)&one; + return _PyLong_FromByteArray(bytes, sizeof(size_t), little, 0); + } +#else + return PyInt_FromSize_t(ival); +#endif +} +static CYTHON_INLINE size_t __Pyx_PyInt_AsSize_t(PyObject* x) { + unsigned PY_LONG_LONG val = __Pyx_PyInt_AsUnsignedLongLong(x); + if (unlikely(val != (unsigned PY_LONG_LONG)(size_t)val)) { + if ((val != (unsigned PY_LONG_LONG)-1) || !PyErr_Occurred()) + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to size_t"); + return (size_t)-1; + } + return (size_t)val; +} + + +#endif /* Py_PYTHON_H */ diff --git a/pyx/tictoc_1.pyx b/pyx/tictoc_1.pyx new file mode 100644 index 0000000..0fdd8d1 --- /dev/null +++ b/pyx/tictoc_1.pyx @@ -0,0 +1,10 @@ +import time + +def test(): + for i in range(0,1000000000): + b=i + +tic = time.time() +test() +toc = time.time()-tic +print toc diff --git a/pyx/tictoc_1.so b/pyx/tictoc_1.so new file mode 100755 index 0000000000000000000000000000000000000000..38d57c41d0f7069c69f79dacf6173772af08b7c6 GIT binary patch literal 64232 zcmeFa33yf2)i-|5JsHkrNWvtDh*uII4rDNZsGwZN8w?OgK&-Nd+$#n^G0_@lrQeR7$DI$lzemsjaq@oK_b^A*~yoTAB=l+tbv+ELH1dWoKMO@D{;%VIhJmz2gF zWm|vH9sHXOBWVj2h@ruSnEJ^K*#Sw7lPKA1kEUl_Nvf8F-b zvDQ-)ivcRS#0{eOEHeWo48uC~L-pKuuZ%ZHJ__AvBqhtcy#hv6?ejGocM$O#>W|B=JUhZrk_ zf63R>!^l5y7(bkK82Yt`k<)M(`nto=-+_XMimS1Q;jaLHDA_3BHHXpj*N36cIgI>4 zhoQTNp|_&%L+L*b^br0fU&9Y0=U-qvl$^Ps4@(vT{Qbk&_4r}vzdB66KLCFpYmgP1 z8dAMT4rkiwYxTCC;^N@Dwm?o_tST#wQd7(V)1u<@qXYY|XP@mO?nYjbm~Ar8K2%@y^r=&aaMz~#*qRk2AGRToAh&nkXo95aPsYFkxw7J8f7+}zlVN|aHLb9Utg zv8p)r4aeiGEpCXbj!POF76C19ZGt&kPs2MIf>A^J*seGptEZjOS@0p$ZH3vT%Szx` z(@ZgTlQ6Bdp(S23N}(wJ9Z0k0x7){4feE8-O} ztg@v=&pVJBs;%iI#gisSPs%$fPd23o&G`Qgg0!SA+w%X%eV1+3`qskM!L``l1*{Ix zc**%o&LbPlW`Fa9kg6AYsi98{A50hAnshLIfZ5QyN%Rfo;1Eip?>6}~H;KN`^cP8@ zzhwAJljs`_e^U~@&G5G+(f`Nr-F(Qh~W+mq;f4F9eq`hAAKGl{;{@b62a zZ!!E?lS39S@qftV_d!YY2f`t;S>uxExrTpY5`AkpM0RUo61~&tvp9*qEgT}dwJwRi z&hT$YqCXxEk=@#oL@zMN{!@GnTBzZ?#c-D*psuQdECljv`RL*TZo%}MmT4F6q8 z^moD`vRfO@&?V1M{3q9qKDz%byxB+hpGEKT(f#N8Ek62C5sq@Jk3P&t-|nMl`{=uT z^a3A!w~s#3M}NsjKh8(rI_fp<*|DKH(M0gs4z;-fo0dX|r#;-e4p(Nlf&kdMwj z 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