Add malloc example

Author: gjbex

source-code/cython/Classes/points.pyx

@@ -1,27 +1,27 @@
-from math import sqrt
+from libc.math cimport sqrt
 
 cdef class Point:
 
-    cdef double x, y
+    cdef double _x, _y
 
     def __init__(self, x, y):
-        self.x = x
-        self.y = y
+        self._x = x
+        self._y = y
 
-    def distance(self):
-        return sqrt(self.x**2 + self.y**2)
+    cpdef distance(self, other):
+        return sqrt((self._x - other._x)**2 + (self._y - other._y)**2)
 
     property x:
         def __get__(self):
-            return self.x
+            return self._x
         def __set__(self, value):
-            self.x = float(value)
+            self._x = float(value)
 
     property y:
         def __get__(self):
-            return self.y
+            return self._y
         def __set__(self, value):
-            self.y = float(value)            
+            self._y = float(value)            
 
 
 class ColoredPoint(Point):

source-code/cython/Classes/points_pure.py

@@ -1,34 +1,56 @@
 import cython
-from math import sqrt
+from cython.cimports.libc.math import sqrt
+
+
+@cython.cfunc
+def _min_max_distance(points: cython.list) -> cython.tuple[cython.double, cython.double]:
+    min_distance : cython.double = 2.0   
+    max_distance : cython.double = 0.0
+    for i in range(len(points)):
+        p1 : Point = points[i]
+        for j in range(i+1, len(points)):
+            p2 : Point = points[j]
+            distance = sqrt((p1._x - p2._x)*(p1._x - p2._x) + (p1._y - p2._y)*(p1._y - p2._y))
+            if distance < min_distance:
+                min_distance = distance
+            if distance > max_distance:
+                max_distance = distance
+    return min_distance, max_distance
+
 
 @cython.cclass
 class Point:
 
-    x: cython.float
-    y: cython.float
+    _x: cython.double
+    _y: cython.double
 
-    def __init__(self, x: cython.float, y: cython.float) -> None:
-        self.x = x
-        self.y = y
+    def __init__(self, x: cython.double, y: cython.double) -> None:
+        self._x = x
+        self._y = y
 
-    def distance(self) -> cython.float:
-        return sqrt(self.x**2 + self.y**2)
+    @cython.ccall
+    def distance(self, other: Point) -> cython.double:
+        return sqrt((self._x - other._x)*(self._x - other._x) + (self._y - other._y)*(self._y - other._y))
 
+    @staticmethod
+    def min_max_distance(points: list) -> tuple[float, float]:
+        return _min_max_distance(points)
+
     @property
-    def x(self) -> cython.float:
-        return self.x
+    def x(self) -> cython.double:
+        return self._x
 
     @x.setter
-    def x(self, value: cython.float) -> None:
-        self.x = float(value)
+    def x(self, value: cython.double) -> None:
+        self._x = float(value)
 
     @property
-    def y(self) -> cython.float:
-        return self.y
+    def y(self) -> cython.double:
+        return self._y
 
     @y.setter
-    def y(self, value: cython.float) -> None:
-        self.y = float(value)
+    def y(self, value: cython.double) -> None:
+        self._y = float(value)
 
     def __str__(self) -> str:
         return f"Point({self.x}, {self.y})"

source-code/cython/Primes/.gitignore

@@ -1,3 +1,4 @@
 primes_cython.c
 primes_cython3.c
 primes_pure_python.c
+primes_malloc.c

source-code/cython/Primes/Makefile

@@ -1,6 +1,7 @@
 VERSION = cpython-311-x86_64-linux-gnu
 PRIMES_LIBS = primes_cython.$(VERSION).so primes_cython3.$(VERSION).so \
-			  primes_pure_python.$(VERSION).so
+			  primes_pure_python.$(VERSION).so primes_pure_malloc.$(VERSION).so \
+			  primes_malloc.$(VERSION).so
 
 all: $(PRIMES_LIBS)
 
@@ -9,5 +10,5 @@ $(PRIMES_LIBS): primes_cython.pyx primes_pure_python.py
 
 clean:
 	python setup.py clean
-	$(RM) primes_cython.c primes_cython3.c primes_pure_python.c $(PRIMES_LIBS)
+	$(RM) primes_cython.c primes_cython3.c primes_pure_python.c primes_malloc.c $(PRIMES_LIBS)
 	$(RM) -r build/

source-code/cython/Primes/README.md

@@ -10,6 +10,9 @@ Motivating example for using Cython
 1. `primes_pure_python.py`: Cython pure Python implementation of the
    primes function.
 1. `setup.py`: Python build script.
+1. `primes_malloc.pyx`: illustration of using `malloc` in Cython.
+1. `primes_pure_malloc.pyx`: illustration of using `malloc` in Cython's
+   pure Python syntax.
 1. `Makefile`: make file to build the extension.
 1. `time_all.sh`: timings with hyperfine, **Note:** due to short runtimes
    these timings are donated by Python interpreter startup times and