Cython
Python'u C hızında çalıştırmak.

mkdir cython-demo && cd cython-demo
python3 -m venv .venv
source .venv/bin/activate

pip install cython setuptools
cython --version   # Cython version 3.x.x

python -c "import Cython; print(Cython.__version__)"
# 3.0.11  (ya da benzer)
python -c "import sysconfig; print(sysconfig.get_config_var('CC'))"
# gcc  — derleyici bulundu

def greet(name):
    return f"Merhaba, {name}!"

def square(x):
    return x * x

from setuptools import setup
from Cython.Build import cythonize

setup(
    ext_modules=cythonize("hello.pyx", language_level=3)
)

python setup.py build_ext --inplace
# Running build_ext
# building 'hello' extension
# gcc -shared -fPIC ... -o hello.cpython-311-x86_64-linux-gnu.so

python -c "import hello; print(hello.greet('Ali')); print(hello.square(7))"
Merhaba, Ali!
49

import pyximport
pyximport.install(language_level=3)
import hello   # ilk kullanımda derlenir
print(hello.greet('Ali'))

wc -l hello.c
2156 hello.c
head -30 hello.c
# /* Generated by Cython 3.x.x */
# #define PY_SSIZE_T_CLEAN
# #include "Python.h"
# ...

# Versiyon A — saf Python (tip yok)
def fib_py(n):
    a, b = 0, 1
    while b < n:
        a, b = b, a + b
    return b

# Versiyon B — def + cdef lokal değişkenler
def fib_typed(long n):
    cdef long a = 0, b = 1
    while b < n:
        a, b = b, a + b
    return b

# Versiyon C — saf C fonksiyonu (Python'dan çağrılamaz)
cdef long _fib_c(long n):
    cdef long a = 0, b = 1
    while b < n:
        a, b = b, a + b
    return b

# Python wrapper — cdef fonksiyonunu dışarıya açar
cpdef long fib(long n):
    return _fib_c(n)

python -m timeit -s "import fib" "fib.fib_py(1_000_000)"
1000000 loops, best of 5: 4.12 µs per loop

python -m timeit -s "import fib" "fib.fib_typed(1_000_000)"
1000000 loops, best of 5: 0.31 µs per loop

python -m timeit -s "import fib" "fib.fib(1_000_000)"
1000000 loops, best of 5: 0.09 µs per loop

cdef struct Point:
    double x
    double y

ctypedef double real_t   # tip takma adı

cdef union IntOrFloat:
    int    i
    float  f

cpdef double distance(Point a, Point b):
    cdef double dx = a.x - b.x
    cdef double dy = a.y - b.y
    from libc.math cimport sqrt
    return sqrt(dx*dx + dy*dy)

def test_distance():
    cdef Point p1 = Point(x=0.0, y=0.0)
    cdef Point p2 = Point(x=3.0, y=4.0)
    return distance(p1, p2)   # → 5.0

from libc.stdlib cimport malloc, free
from libc.string cimport memset

def make_array(int n):
    cdef int* arr
    cdef int  i

    arr = <int*>malloc(n * sizeof(int))
    if arr == NULL:
        raise MemoryError("malloc başarısız")

    for i in range(n):
        arr[i] = i * i        # pointer aritmetiği: arr[i] = *(arr + i)

    result = [arr[i] for i in range(n)]

    free(arr)                 # MUTLAKA serbest bırak
    return result

from libc.stdlib cimport malloc, free, realloc, qsort
from libc.string cimport memcpy, memset, strlen, strcmp
from libc.math   cimport sqrt, sin, cos, log, exp, fabs, pow
from libc.stdio  cimport printf, fprintf, fopen, fclose

from libc.math cimport sqrt

cdef class Vector2D:
    cdef public double x    # Python'dan okuma ve yazma
    cdef public double y

    def __cinit__(self, double x, double y):
        # C-level init — her koşulda çalışır, override edilemez
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Vector2D({self.x}, {self.y})"

    cpdef double magnitude(self):
        return sqrt(self.x * self.x + self.y * self.y)

    cpdef double dot(self, Vector2D other):
        return self.x * other.x + self.y * other.y

    def normalize(self):
        cdef double m = self.magnitude()
        if m == 0.0:
            raise ValueError("Sıfır vektörü normalize edilemez")
        return Vector2D(self.x / m, self.y / m)

from libc.stdlib cimport malloc, free

cdef class IntBuffer:
    cdef int* data
    cdef public int size

    def __cinit__(self, int size):
        self.size = size
        self.data = <int*>malloc(size * sizeof(int))
        if self.data == NULL:
            raise MemoryError()

    def __dealloc__(self):
        if self.data != NULL:
            free(self.data)   # nesne yok edildiğinde otomatik çalışır

    def __setitem__(self, int i, int val):
        if i < 0 or i >= self.size:
            raise IndexError(i)
        self.data[i] = val

    def __getitem__(self, int i):
        if i < 0 or i >= self.size:
            raise IndexError(i)
        return self.data[i]

cdef extern from "math.h":
    double sin(double x) nogil
    double cos(double x) nogil
    double sqrt(double x) nogil

def py_sin(double x):
    return sin(x)   # doğrudan C sin() çağrısı

// stats.c
#include "stats.h"
#include <stdlib.h>

double mean(const double* data, int n) {
    double sum = 0.0;
    for (int i = 0; i < n; i++) sum += data[i];
    return sum / n;
}

double variance(const double* data, int n) {
    double m = mean(data, n), v = 0.0;
    for (int i = 0; i < n; i++) v += (data[i]-m)*(data[i]-m);
    return v / n;
}

double mean(const double* data, int n);
double variance(const double* data, int n);

cdef extern from "stats.h":
    double mean(const double* data, int n) nogil
    double variance(const double* data, int n) nogil

def py_mean(list data):
    cdef int n = len(data)
    cdef double* arr = <double*>malloc(n * sizeof(double))
    from libc.stdlib cimport malloc, free
    if arr == NULL: raise MemoryError()
    try:
        for i in range(n): arr[i] = data[i]
        return mean(arr, n)
    finally:
        free(arr)

from setuptools import setup, Extension
from Cython.Build import cythonize

ext = Extension(
    "pystats",
    sources=["pystats.pyx", "stats.c"],   # hem .pyx hem .c
    libraries=["m"],                        # -lm (libm)
)
setup(ext_modules=cythonize([ext], language_level=3))

# C fonksiyon -1 dönerse Python exception oluştur
cdef int might_fail(int x) except -1:
    ...

# Herhangi bir dönüş değerinde PyErr kontrolü yap (yavaş)
cdef int uncertain(int x) except? -1:
    ...

# void fonksiyon — her çağrıdan sonra kontrol et
cdef void also_might_fail(int x) except*:
    ...

cdef extern from "mylib.h":
    ctypedef struct MyRecord:
        int    id
        double value
        char*  label

    MyRecord* record_new(int id, double val) except NULL
    void record_free(MyRecord* r)

def matmul(double[:, :] A, double[:, :] B, double[:, :] C):
    """C = A @ B (in-place, C önceden sıfırlanmış olmalı)"""
    cdef int i, j, k
    cdef int M = A.shape[0]
    cdef int K = A.shape[1]
    cdef int N = B.shape[1]
    for i in range(M):
        for j in range(N):
            for k in range(K):
                C[i, j] += A[i, k] * B[k, j]

import numpy as np
import matmul

A = np.random.rand(100, 100)
B = np.random.rand(100, 100)
C = np.zeros((100, 100))

matmul.matmul(A, B, C)   # sıfır kopya — A,B,C bellekte tutulur

# cython: boundscheck=False, wraparound=False

def matmul_fast(double[:, ::1] A,
                double[:, ::1] B,
                double[:, ::1] C):
    cdef int i, j, k
    cdef int M = A.shape[0], K = A.shape[1], N = B.shape[1]
    for i in range(M):
        for j in range(N):
            for k in range(K):
                C[i, j] = C[i, j] + A[i, k] * B[k, j]

# Saf Python döngüsü:
~8500 µs  (85 ms)

# Typed memoryview, boundscheck açık:
~180 µs

# Typed memoryview [:, ::1], boundscheck=False:
~38 µs

# NumPy @ operatörü (BLAS):
~6 µs   ← BLAS paralel SIMD kullandığı için kazanır

# Bu yöntem çalışır ama artık önerilmiyor
import numpy as np
cimport numpy as np

def old_style(np.ndarray[np.float64_t, ndim=2] A):
    cdef int i, j
    for i in range(A.shape[0]):
        for j in range(A.shape[1]):
            A[i, j] *= 2.0

from libc.math cimport sin, sqrt

# GIL gerektirmeyen saf hesaplama
cdef double heavy_compute(double x) nogil:
    return sin(x) * sqrt(x + 1.0)

# Python'dan çağrılabilir wrapper
def compute_single(double x):
    return heavy_compute(x)   # GIL otomatik tutulur

# Uzun hesaplama — GIL'i geçici bırak
def compute_many(double[:] data, double[:] out):
    cdef int i, n = data.shape[0]
    with nogil:                # bu blok içinde GIL yok
        for i in range(n):
            out[i] = heavy_compute(data[i])

from cython.parallel cimport prange

def parallel_compute(double[:] data, double[:] out):
    cdef int i, n = data.shape[0]
    # GIL olmadan OpenMP ile paralel döngü
    for i in prange(n, nogil=True, schedule='static'):
        out[i] = heavy_compute(data[i])

def parallel_sum(double[:] data) -> double:
    cdef int    i, n = data.shape[0]
    cdef double total = 0.0
    # Cython reduction'ı otomatik tespit eder
    for i in prange(n, nogil=True):
        total += data[i]
    return total

from setuptools import setup, Extension
from Cython.Build import cythonize

ext = Extension(
    "parallel",
    sources=["parallel.pyx"],
    extra_compile_args=["-fopenmp"],
    extra_link_args=["-fopenmp"],
)
setup(ext_modules=cythonize([ext], language_level=3))

cython -a matmul.pyx
# matmul.html dosyası üretildi
xdg-open matmul.html   # ya da tarayıcıda aç

# cython: language_level=3
# cython: boundscheck=False
# cython: wraparound=False
# cython: cdivision=True
# cython: initializedcheck=False

def matmul_opt(double[:, ::1] A,
               double[:, ::1] B,
               double[:, ::1] C):
    cdef int i, j, k
    cdef int M = A.shape[0], K = A.shape[1], N = B.shape[1]
    for i in range(M):
        for j in range(N):
            for k in range(K):
                C[i, j] = C[i, j] + A[i, k] * B[k, j]

cimport cython

@cython.boundscheck(False)
@cython.wraparound(False)
def hot_loop(double[:] data):
    cdef int i, n = data.shape[0]
    for i in range(n):
        data[i] *= 2.0

# cython: profile=True
# Derle, sonra cProfile ile çalıştır

python -m cProfile -s cumtime myscript.py

from setuptools import setup, Extension
from Cython.Build import cythonize

ext = Extension(
    name="mymod",
    sources=["mymod.pyx", "helper.c"],
    include_dirs=["./include"],
    library_dirs=["/usr/local/lib"],
    libraries=["m"],
    extra_compile_args=["-O3", "-fopenmp", "-march=native"],
    extra_link_args=["-fopenmp"],
)

setup(
    name="mymod",
    ext_modules=cythonize(
        [ext],
        language_level=3,
        annotate=True,            # setup sırasında da HTML üret
        compiler_directives={
            "boundscheck": False,
            "wraparound":  False,
        }
    )
)

[build-system]
requires = ["setuptools>=64", "cython>=3.0", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "mymod"
version = "0.1.0"
requires-python = ">=3.8"

import pyximport
pyximport.install(
    language_level=3,
    setup_args={"include_dirs": ["./include"]}
)
import mymod   # .pyx değiştiyse otomatik yeniden derlenir

pip install build

# Source distribution (tarball)
python -m build --sdist
# dist/mymod-0.1.0.tar.gz içinde: .pyx + üretilmiş .c
# Kullanıcıda Cython yoksa .c'den derler — yeterlidir

# Binary wheel (platform-özel)
python -m build --wheel
# dist/mymod-0.1.0-cp311-cp311-linux_x86_64.whl
# İçinde: derlenmiş .so — kurulumda derleme gerekmez

pip install cibuildwheel

# Yerel: sadece mevcut platform
cibuildwheel --platform linux .

# CI'da (GitHub Actions): Linux × macOS × Windows × Python 3.8–3.12

- uses: pypa/cibuildwheel@v2
  with:
    package-dir: .
    output-dir: wheelhouse
  env:
    CIBW_BUILD: "cp38-* cp39-* cp310-* cp311-* cp312-*"

include *.pyx
include *.c
include *.h