# sum_cy.pyx
def cy_sum(n):
    """用 Cython 计算 0 到 n-1 的和"""
    total = 0
    for i in range(n):
        total += i
    return total

from setuptools import setup
from Cython.Build import cythonize

setup(
    ext_modules=cythonize("sum_cy.pyx")
)

python3 setup.py build_ext --inplace

# sum_typed.pyx

# C 级变量声明 — 消除 Python 对象开销
def cy_sum_typed(int n):
    cdef long total = 0    # C long 类型
    cdef int i             # C int 类型
    for i in range(n):
        total += i
    return total

import time

# 纯 Python
def py_sum(n):
    total = 0
    for i in range(n):
        total += i
    return total

# 测试
n = 10_000_000

start = time.perf_counter()
py_sum(n)
py_time = time.perf_counter() - start

start = time.perf_counter()
cy_sum_typed(n)  # Cython 版本
cy_time = time.perf_counter() - start

print(f"Python:  {py_time:.3f}s")
print(f"Cython:  {cy_time:.3f}s")
print(f"加速比:  {py_time/cy_time:.1f}x")

import ctypes

# 加载 C 标准库
libc = ctypes.CDLL("libc.so.6")  # Linux
# libc = ctypes.CDLL("msvcrt")   # Windows

# 调用 abs()
result = libc.abs(-42)
print(result)  # 42

# 调用 strlen()
libc.strlen.argtypes = [ctypes.c_char_p]  # 声明参数类型
libc.strlen.restype = ctypes.c_size_t     # 声明返回类型
result = libc.strlen(b"Hello, World!")
print(result)  # 13

// fast_math.c
#include <math.h>

double fast_sin(double x) {
    return sin(x);
}

long long fast_factorial(int n) {
    long long result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

gcc -shared -o fast_math.so -fPIC fast_math.c -lm

import ctypes

# 加载共享库
lib = ctypes.CDLL("./fast_math.so")

# 声明函数签名
lib.fast_sin.argtypes = [ctypes.c_double]
lib.fast_sin.restype = ctypes.c_double

lib.fast_factorial.argtypes = [ctypes.c_int]
lib.fast_factorial.restype = ctypes.c_longlong

# 调用
print(lib.fast_sin(3.14159))      # ≈ 0
print(lib.fast_factorial(20))     # 2432902008176640000

import ctypes

# 创建 C 数组
arr = (ctypes.c_double * 5)(1.0, 2.0, 3.0, 4.0, 5.0)

# 传给 C 函数
lib.sum_array.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int]
lib.sum_array.restype = ctypes.c_double

result = lib.sum_array(arr, 5)
print(result)  # 15.0

from cffi import FFI

ffi = FFI()

# 声明 C 函数签名（直接写 C 语法）
ffi.cdef("""
    double sin(double x);
    long long factorial(int n);
""")

# 加载共享库
C = ffi.dlopen("libc.so.6")

# 调用
print(C.sin(3.14159))  # ≈ 0

from cffi import FFI

ffi = FFI()
ffi.cdef("""
    double fast_sin(double x);
    long long fast_factorial(int n);
""")

lib = ffi.dlopen("./fast_math.so")
print(lib.fast_sin(1.5708))  # ≈ 1.0 (sin(π/2))
print(lib.fast_factorial(10))  # 3628800

# build_ffi.py — 运行一次生成绑定
from cffi import FFI

ffi = FFI()
ffi.cdef("""
    double fast_sin(double x);
    long long fast_factorial(int n);
""")

ffi.set_source("_fast_math_cffi", """
    #include "fast_math.c"  // 直接包含 C 源码
""", sources=["fast_math.c"])

ffi.compile()

# 使用编译后的绑定
from _fast_math_cffi import ffi, lib

print(lib.fast_sin(1.0))
print(lib.fast_factorial(5))

from numba import jit
import time

@jit(nopython=True)  # nopython=True 强制编译为纯机器码
def monte_carlo_pi(n_samples):
    """用蒙特卡洛方法估算 π"""
    import random
    count = 0
    for i in range(n_samples):
        x = random.random()
        y = random.random()
        if x**2 + y**2 <= 1.0:
            count += 1
    return 4.0 * count / n_samples

# 首次调用会编译（较慢）
start = time.perf_counter()
pi = monte_carlo_pi(10_000_000)
first_call = time.perf_counter() - start

# 后续调用直接用机器码（很快）
start = time.perf_counter()
pi = monte_carlo_pi(10_000_000)
fast_call = time.perf_counter() - start

print(f"首次调用（含编译）: {first_call:.3f}s")
print(f"后续调用: {fast_call:.3f}s")
print(f"π ≈ {pi}")

from numba import jit, prange
import numpy as np

@jit(nopython=True, parallel=True)
def parallel_sum(arr):
    """并行求和"""
    total = 0.0
    for i in prange(len(arr)):  # prange 替代 range
        total += arr[i]
    return total

data = np.random.rand(100_000_000)
result = parallel_sum(data)
print(f"Sum: {result}")

# 方式 1：纯 Python
def pure_python_pi(n):
    import random
    count = 0
    for _ in range(n):
        x, y = random.random(), random.random()
        if x*x + y*y <= 1:
            count += 1
    return 4 * count / n

# 方式 2：NumPy 向量化
import numpy as np
def numpy_pi(n):
    x = np.random.rand(n)
    y = np.random.rand(n)
    return 4 * np.sum(x*x + y*y <= 1) / n

# 方式 3：Numba JIT
from numba import jit
@jit(nopython=True)
def numba_pi(n):
    count = 0
    for _ in range(n):
        x = np.random.random()
        y = np.random.random()
        if x*x + y*y <= 1:
            count += 1
    return 4 * count / n

# 方式 4：Cython 版本见 code/03-cython-monte-carlo.pyx

# ❌ 错误：在计时代码中包含首次调用
start = time.time()
result = jit_func(data)  # 首次调用包含编译时间！
elapsed = time.time() - start

# ✅ 正确：先预热再计时
jit_func(data)  # 预热（编译）
start = time.time()
result = jit_func(data)  # 真正的执行时间
elapsed = time.time() - start

# ❌ 不声明类型（每次都转换，很慢）
lib.func(arg)

# ✅ 声明类型（自动转换，更快）
lib.func.argtypes = [ctypes.c_double]
lib.func.restype = ctypes.c_double
lib.func(arg)

# ❌ .pyx 文件不能直接 import
import sum_cy  # ModuleNotFoundError

# ✅ 必须先编译
# python3 setup.py build_ext --inplace
import sum_cy  # 现在可以了

# ❌ Numba 不支持普通 Python class
@jit(nopython=True)
class MyClass:  # 会报错
    pass

# ✅ 用 namedtuple 代替
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])

@jit(nopython=True)
def use_point():
    p = Point(1.0, 2.0)  # namedtuple 可以用
    return p.x + p.y