#integrate.py
def f(x):
    return x ** 2 - x


def integrate_f(a, b, N):
    s = 0
    dx = (b - a) / N
    for i in range(N):
        s += f(a + i * dx)
    return s * dx

#integrate_cython.pyx
def f(double x):
    return x ** 2 - x


def integrate_f(double a, double b, int N):
    cdef int i
    cdef double s
    cdef double dx
    s = 0
    dx = (b - a) / N
    for i in range(N):
        s += f(a + i * dx)
    return s * dx

#cython
integrate_f(10, 100, 10000000) ==> 0.70242
#Python
integrate_f(10, 100, 10000000) ==> 1.97632

#setup.py
from setuptools import setup
from Cython.Build import cythonize

setup(
    name='intg_cython',
    ext_modules=cythonize("integrate_cython.pyx"),
    zip_safe=False,
)

$ python setup.py build_ext --inplace

// #define __Pyx_XDECREF(r) Py_XDECREF(r)
// #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
// #define __Pyx_MODULE_NAME "integrate_cython"

static PyObject *__pyx_pf_16integrate_cython_f(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_x) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;
  //해당 fucntion의 이름을 context에 저장
  __Pyx_RefNannySetupContext("f", 0);

  /* "integrate_cython.pyx":2
 * def f(double x):
 *     return x ** 2 - x             # <<<<<<<<<<<<<<
 * 
 * 
 */
  __Pyx_XDECREF(__pyx_r);
  //return으로 반환할 값을 PyObject형식으로 변환 및 예외처리
  __pyx_t_1 = PyFloat_FromDouble((pow(__pyx_v_x, 2.0) - __pyx_v_x)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  //ret값을 __pyx_t_1에 저장된 값을 가지고와서 할당함
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "integrate_cython.pyx":1
 * def f(double x):             # <<<<<<<<<<<<<<
 *     return x ** 2 - x
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("integrate_cython.f", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

...
static struct PyModuleDef __pyx_moduledef = {
    PyModuleDef_HEAD_INIT,
    "integrate_cython",
    0, /* m_doc */
  #if CYTHON_PEP489_MULTI_PHASE_INIT
    0, /* m_size */
  #else
    -1, /* m_size */
  #endif
    __pyx_methods /* m_methods */,
  #if CYTHON_PEP489_MULTI_PHASE_INIT
    __pyx_moduledef_slots, /* m_slots */
  #else
    NULL, /* m_reload */
  #endif
    NULL, /* m_traverse */
    NULL, /* m_clear */
    NULL /* m_free */
};
...
  __pyx_m = PyModule_Create(&__pyx_moduledef);
  ...
  return __pyx_m
 

"""
cython code -> CPython code -> setup.py -> .pyd(PyDLL) code
"""

#https://cython.readthedocs.io/en/latest/src/tutorial/memory_allocation.html
import random
from libc.stdlib cimport malloc, free

def random_noise(int number=1):
    cdef int i
    # C 라이브러리인 malloc을 통해서 메모리를 확보
    cdef double *my_array = <double *> malloc(number * sizeof(double))    
    try:
        ran = random.normalvariate
        for i in range(number):
            my_array[i] = ran(0, 1)
        #포인터를 리턴할 경우 python에서 해당 값을 이해할 수 없음
        #때문에 Python이 인식 가능한 object로 만들어서 반환해줌
        return [x for x in my_array[:number]]
    finally:
        # return the previously allocated memory to the system
        free(my_array)
        
#함수 포인터를 사용하는 패턴
cdef int(*ptr_add)(int, int)
cdef int add(int a, int b):
    return a + b

ptr_add = add
print(ptr_add(1, 3))

#https://cython.readthedocs.io/en/latest/src/tutorial/parallelization.html
from cython.parallel cimport prange
cimport cython
from libc.math cimport sin

import numpy as np

#반복문 중 반복문의 boundcheck여부
@cython.boundscheck(False)
@cython.wraparound(False)
def do_sine(double[:,:] input):
    cdef double[:,:] output = np.empty_like(input)
    cdef Py_ssize_t i, j
    
    #prange 메쏘드를 사용해서 row마다 thread가 별도로 처리
    for i in prange(input.shape[0], nogil=True):
        for j in range(input.shape[1]):
            output[i, j] = sin(input[i, j])
    return np.asarray(output)

//cython 컴파일 한 뒤 C언어 파일에서 아래와같은 #progma mp처리가됨
#pragma omp parallel
{
    #pragma omp for firstprivate(i) lastprivate(i) lastprivate(j)
    for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_9; __pyx_t_8++){
        i = __pyx_t_8;
        /* body goes here */
    }
}

%%cython --annotate
def cython_reduce_sum(object input_list):
    cdef long long ret
    ret = 0
    for val in input_list:
        ret += val
    return ret

def python_reduce_sum(input_list):
    ret = 0
    for val in input_list:
        ret += val
    return ret

cython_reduce_sum([1 for _ in range(100000000)])
#==> 5.453547
python_reduce_sum([1 for _ in range(100000000)])
#==> 5.974197

#https://cython.readthedocs.io/en/latest/src/tutorial/array.html
from cpython cimport array
import array
cdef array.array a = array.array('i', [1, 2, 3])
cdef int[:] ca = a

cdef int overhead(object a):
    cdef int[:] ca = a
    return ca[0]

#array.array를 직접 받지않고 해당 array의 Pointer를 받음으로써
#추가적인 오버헤드 없이 동작이 가능함
cdef int no_overhead(int[:] ca):
    return ca[0]

print(overhead(a))  # new memory view will be constructed, overhead
print(no_overhead(ca))  # ca is already a memory view, so no overhead

from cpython cimport array
import array
def cython_reduce_sum2(int[:] input_array, array_len):
    cdef int[:] parr = input_array
    cdef int ret = 0
    cdef int cnt = 0
    while cnt < array_len:
        ret += parr[cnt]
        cnt += 1
    return ret

import array
import time
dt = array.array("i", [1 for _ in range(100000000)])
st = time.perf_counter()
cython_reduce_sum2(dt, 100000000)
print(time.perf_counter() - st)
#==>1.529048

import time
import array
array.array("i", [1 for _ in range(100000000)])
#==> 5.300749500000165
[1 for _ in range(100000000)]
#==> 3.5525482000000466

def cython_reduce_sum(object input_list):
    cdef int ret = 0
    cdef int val
    for val in input_list:
        ret += val
    return ret

import time
print(cython_reduce_sum([i for i in range(1000000)]))
#==>704982704
print(sum([i for i in range(1000000)]))
#==>4999950000
'''
overflow가 일어난 만큼을 제외한 값이 계산된 것을 볼 수 있다.
4294967296(overflow) + 704982704 = 4999950000
'''