Quickstart: Your First Cython Module¶

def fib(int n):
    """Typed function - modest speedup"""
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)

def fib_iterative(int n):
    """Typed iterative - significant speedup"""
    cdef int a = 0
    cdef int b = 1
    cdef int i
    for i in range(n):
        a, b = b, a + b
    return a

# cython: boundscheck=False, wraparound=False, cdivision=True

cdef long _fib_internal(long n) nogil:
    """Pure C function - maximum speed"""
    cdef long a = 0
    cdef long b = 1
    cdef long i, tmp

    for i in range(n):
        tmp = a
        a = b
        b = tmp + b
    return a

cpdef long fib_fast(long n):
    """Python-accessible fast Fibonacci"""
    if n < 0:
        raise ValueError("n must be non-negative")
    return _fib_internal(n)

def fib_array(long n):
    """Generate Fibonacci sequence as list"""
    cdef long i
    cdef list result = []
    for i in range(n):
        result.append(_fib_internal(i))
    return result

%%cython --annotate

def fib_notebook(int n):
    cdef int a = 0, b = 1, i
    for i in range(n):
        a, b = b, a + b
    return a

# cython: boundscheck=False, wraparound=False
import numpy as np
cimport numpy as cnp

def sum_array(cnp.ndarray[cnp.float64_t, ndim=1] arr):
    """Sum array elements (NumPy array interface)"""
    cdef cnp.float64_t total = 0.0
    cdef Py_ssize_t i
    for i in range(arr.shape[0]):
        total += arr[i]
    return total

def sum_memoryview(double[:] arr):
    """Sum using typed memoryviews (faster)"""
    cdef double total = 0.0
    cdef Py_ssize_t i
    for i in range(arr.shape[0]):
        total += arr[i]
    return total

def matrix_multiply(double[:, :] A, double[:, :] B):
    """Manual matrix multiplication"""
    cdef Py_ssize_t i, j, k
    cdef Py_ssize_t m = A.shape[0]
    cdef Py_ssize_t n = A.shape[1]
    cdef Py_ssize_t p = B.shape[1]

    cdef double[:, :] C = np.zeros((m, p), dtype=np.float64)

    for i in range(m):
        for j in range(p):
            for k in range(n):
                C[i, j] += A[i, k] * B[k, j]

    return np.asarray(C)

from libc.stdlib cimport malloc, free

cdef struct Point:
    double x
    double y
    double z

cdef struct Particle:
    Point position
    Point velocity
    double mass

def create_particle(double px, double py, double pz, 
                    double vx, double vy, double vz, 
                    double mass):
    """Create and manipulate C structures"""
    cdef Particle* p = <Particle*>malloc(sizeof(Particle))

    if p is NULL:
        raise MemoryError("Unable to allocate particle")

    try:
        p.position.x = px
        p.position.y = py
        p.position.z = pz
        p.velocity.x = vx
        p.velocity.y = vy
        p.velocity.z = vz
        p.mass = mass

        # Calculate kinetic energy
        cdef double v_squared = (p.velocity.x ** 2 + 
                                 p.velocity.y ** 2 + 
                                 p.velocity.z ** 2)
        kinetic_energy = 0.5 * p.mass * v_squared

        return {
            'position': (p.position.x, p.position.y, p.position.z),
            'velocity': (p.velocity.x, p.velocity.y, p.velocity.z),
            'mass': p.mass,
            'kinetic_energy': kinetic_energy
        }
    finally:
        free(p)

cdef class Point:
    """High-performance point class"""
    cdef public double x, y, z
    cdef double _magnitude  # Private attribute

    def __init__(self, double x=0, double y=0, double z=0):
        self.x = x
        self.y = y
        self.z = z
        self._magnitude = -1  # Lazy evaluation flag

    cpdef double magnitude(self):
        """Calculate magnitude (cached)"""
        if self._magnitude < 0:
            self._magnitude = (self.x*self.x + self.y*self.y + self.z*self.z) ** 0.5
        return self._magnitude

    cpdef Point add(self, Point other):
        """Add two points"""
        return Point(self.x + other.x, self.y + other.y, self.z + other.z)

    cdef void _normalize(self):
        """Internal normalization (C-only method)"""
        cdef double mag = self.magnitude()
        if mag > 0:
            self.x /= mag
            self.y /= mag
            self.z /= mag
            self._magnitude = 1.0

    def normalize(self):
        """Public normalize method"""
        self._normalize()

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