chore: license, gitignore, pyproject cleanup

Author: basnijholt

.gitignore

@@ -1,6 +1,11 @@
-target/
+.claude/
+.mypy_cache/
 .venv
-*.so
-*.dylib
+/target/
 __pycache__/
-.claude/
+*.dylib
+*.egg-info/
+*.pyc
+*.pyd
+*.so
+dist/

Cargo.toml

@@ -17,7 +17,7 @@ crate-type = ["cdylib", "rlib"]
 criterion = "0.5"
 
 [dependencies]
-pyo3 = { version = "0.23", features = ["extension-module", "abi3-py311"] }
+pyo3 = { version = "0.23", features = ["extension-module", "abi3-py310"] }
 numpy = "0.23"
 nalgebra = "0.33"
 thiserror = "2"

LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) python-adaptive contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

benches/bench_triangulation.rs

@@ -18,10 +18,12 @@ fn generate_points(dim: usize, count: usize, seed: u64) -> Vec<Vec<f64>> {
     for index in 0..count {
         let mut point = Vec::with_capacity(dim);
         for axis in 0..dim {
-            let low_discrepancy = ((index + 1) as f64 * (axis + 2) as f64 * 0.618_033_988_749_894_9)
-                .fract();
+            let low_discrepancy =
+                ((index + 1) as f64 * (axis + 2) as f64 * 0.618_033_988_749_894_9).fract();
             let jitter = next_unit_f64(&mut state);
-            point.push(0.7 * low_discrepancy + 0.3 * jitter + axis as f64 * 1e-4 + index as f64 * 1e-12);
+            point.push(
+                0.7 * low_discrepancy + 0.3 * jitter + axis as f64 * 1e-4 + index as f64 * 1e-12,
+            );
         }
         points.push(point);
     }
@@ -140,11 +142,7 @@ fn add_point_bench(c: &mut Criterion) {
 
 fn circumsphere_benches(c: &mut Criterion) {
     let mut group = c.benchmark_group("circumsphere");
-    let simplex_2d = vec![
-        vec![0.0, 0.0],
-        vec![0.9, 0.1],
-        vec![0.2, 0.8],
-    ];
+    let simplex_2d = vec![vec![0.0, 0.0], vec![0.9, 0.1], vec![0.2, 0.8]];
     let simplex_3d = vec![
         vec![0.0, 0.0, 0.0],
         vec![1.0, 0.1, 0.0],
@@ -174,7 +172,9 @@ fn point_in_circumcircle_bench(c: &mut Criterion) {
                 let mut current = triangulation.clone();
                 let pt_index = insert_pending_vertex(&mut current, point.clone());
                 let start = Instant::now();
-                let inside = current.point_in_circumcircle(pt_index, &simplex, &None).unwrap();
+                let inside = current
+                    .point_in_circumcircle(pt_index, &simplex, &None)
+                    .unwrap();
                 black_box(inside);
                 total += start.elapsed();
             }
@@ -198,7 +198,7 @@ fn locate_and_containing_benches(c: &mut Criterion) {
         .collect();
     let faces: Vec<Simplex> = simplices
         .iter()
-        .map(|simplex| simplex[..triangulation.dim].iter().copied().collect())
+        .map(|simplex| simplex[..triangulation.dim].to_vec())
         .collect();
 
     group.bench_function("locate_point", |b| {

pyproject.toml

@@ -7,13 +7,19 @@ name = "adaptive-triangulation"
 dynamic = ["version"]
 description = "Fast N-dimensional Delaunay triangulation with incremental point insertion"
 readme = "README.md"
+authors = [{ name = "python-adaptive contributors" }]
 license = "BSD-3-Clause"
-requires-python = ">=3.11"
+requires-python = ">=3.10"
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Science/Research",
     "License :: OSI Approved :: BSD License",
     "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Rust",
     "Topic :: Scientific/Engineering :: Mathematics",
@@ -27,6 +33,7 @@ test = ["pytest>=7.0", "scipy>=1.10"]
 
 [project.urls]
 Homepage = "https://github.com/python-adaptive/adaptive-triangulation"
+Issues = "https://github.com/python-adaptive/adaptive-triangulation/issues"
 Repository = "https://github.com/python-adaptive/adaptive-triangulation"
 
 [tool.maturin]

src/geometry.rs

@@ -126,11 +126,7 @@ pub fn matrix_rank(vectors: &[Vec<f64>], tol: f64) -> Result<usize, GeometryErro
     let rows = vectors.len();
     let flat: Vec<f64> = vectors.iter().flat_map(|row| row.iter().copied()).collect();
     let svd = DMatrix::from_row_slice(rows, cols, &flat).svd(false, false);
-    let max_singular = svd
-        .singular_values
-        .iter()
-        .copied()
-        .fold(0.0_f64, f64::max);
+    let max_singular = svd.singular_values.iter().copied().fold(0.0_f64, f64::max);
     let tol = if tol.is_sign_positive() {
         tol
     } else {
@@ -155,24 +151,25 @@ pub fn fast_2d_point_in_simplex(
     let [[p0x, p0y], [p1x, p1y], [p2x, p2y]] = *simplex;
     let [px, py] = *point;
 
-    let area: f64 = 0.5
-        * (-p1y * p2x + p0y * (p2x - p1x) + p1x * p2y + p0x * (p1y - p2y));
+    let area: f64 = 0.5 * (-p1y * p2x + p0y * (p2x - p1x) + p1x * p2y + p0x * (p1y - p2y));
     if area == 0.0 {
         return Err(GeometryError::DegenerateSimplex);
     }
 
-    let s = 1.0 / (2.0 * area)
-        * (p0y * p2x + (p2y - p0y) * px - p0x * p2y + (p0x - p2x) * py);
+    let s = 1.0 / (2.0 * area) * (p0y * p2x + (p2y - p0y) * px - p0x * p2y + (p0x - p2x) * py);
     if s < -eps || s > 1.0 + eps {
         return Ok(false);
     }
 
-    let t = 1.0 / (2.0 * area)
-        * (p0x * p1y + (p0y - p1y) * px - p0y * p1x + (p1x - p0x) * py);
+    let t = 1.0 / (2.0 * area) * (p0x * p1y + (p0y - p1y) * px - p0y * p1x + (p1x - p0x) * py);
     Ok(t >= -eps && s + t <= 1.0 + eps)
 }
 
-pub fn point_in_simplex(point: &[f64], simplex: &[Vec<f64>], eps: f64) -> Result<bool, GeometryError> {
+pub fn point_in_simplex(
+    point: &[f64],
+    simplex: &[Vec<f64>],
+    eps: f64,
+) -> Result<bool, GeometryError> {
     if simplex.is_empty() || simplex.len() != point.len() + 1 {
         return Err(GeometryError::InvalidDimensions(
             "Simplex dimension mismatch".to_string(),
@@ -247,14 +244,10 @@ pub fn fast_3d_circumsphere(points: &[[f64; 3]; 4]) -> ([f64; 3], f64) {
     let l2 = x2 * x2 + y2 * y2 + z2 * z2;
     let l3 = x3 * x3 + y3 * y3 + z3 * z3;
 
-    let dx = l1 * (y2 * z3 - z2 * y3) - l2 * (y1 * z3 - z1 * y3)
-        + l3 * (y1 * z2 - z1 * y2);
-    let dy = l1 * (x2 * z3 - z2 * x3) - l2 * (x1 * z3 - z1 * x3)
-        + l3 * (x1 * z2 - z1 * x2);
-    let dz = l1 * (x2 * y3 - y2 * x3) - l2 * (x1 * y3 - y1 * x3)
-        + l3 * (x1 * y2 - y1 * x2);
-    let aa = x1 * (y2 * z3 - z2 * y3) - x2 * (y1 * z3 - z1 * y3)
-        + x3 * (y1 * z2 - z1 * y2);
+    let dx = l1 * (y2 * z3 - z2 * y3) - l2 * (y1 * z3 - z1 * y3) + l3 * (y1 * z2 - z1 * y2);
+    let dy = l1 * (x2 * z3 - z2 * x3) - l2 * (x1 * z3 - z1 * x3) + l3 * (x1 * z2 - z1 * x2);
+    let dz = l1 * (x2 * y3 - y2 * x3) - l2 * (x1 * y3 - y1 * x3) + l3 * (x1 * y2 - y1 * x2);
+    let aa = x1 * (y2 * z3 - z2 * y3) - x2 * (y1 * z3 - z1 * y3) + x3 * (y1 * z2 - z1 * y2);
     let a = 2.0 * aa;
 
     let cx = dx / a;
@@ -344,8 +337,8 @@ fn slogdet(matrix: &[Vec<f64>]) -> Result<(f64, f64), GeometryError> {
     for pivot_col in 0..n {
         let mut pivot_row = pivot_col;
         let mut pivot_abs = work[pivot_col][pivot_col].abs();
-        for row in (pivot_col + 1)..n {
-            let candidate = work[row][pivot_col].abs();
+        for (row, values) in work.iter().enumerate().skip(pivot_col + 1) {
+            let candidate = values[pivot_col].abs();
             if candidate > pivot_abs {
                 pivot_abs = candidate;
                 pivot_row = row;
@@ -368,11 +361,12 @@ fn slogdet(matrix: &[Vec<f64>]) -> Result<(f64, f64), GeometryError> {
         sign *= pivot.signum();
         log_abs_det += pivot.abs().ln();
 
-        for row in (pivot_col + 1)..n {
-            let factor = work[row][pivot_col] / pivot;
-            work[row][pivot_col] = 0.0;
-            for col in (pivot_col + 1)..n {
-                work[row][col] -= factor * work[pivot_col][col];
+        let pivot_values = work[pivot_col].clone();
+        for row_values in work.iter_mut().skip(pivot_col + 1) {
+            let factor = row_values[pivot_col] / pivot;
+            row_values[pivot_col] = 0.0;
+            for (col, value) in row_values.iter_mut().enumerate().skip(pivot_col + 1) {
+                *value -= factor * pivot_values[col];
             }
         }
     }
@@ -450,9 +444,11 @@ pub fn simplex_volume_in_embedding(vertices: &[Vec<f64>]) -> Result<f64, Geometr
 
     let n = vertices.len();
     let mut matrix = vec![vec![0.0; n + 1]; n + 1];
-    for idx in 1..=n {
-        matrix[0][idx] = 1.0;
-        matrix[idx][0] = 1.0;
+    for value in matrix[0].iter_mut().skip(1) {
+        *value = 1.0;
+    }
+    for row in matrix.iter_mut().skip(1) {
+        row[0] = 1.0;
     }
     for row in 0..n {
         for col in 0..n {

src/lib.rs

@@ -51,12 +51,10 @@ fn _rust(m: &Bound<'_, PyModule>) -> PyResult<()> {
 
 #[pyfunction]
 #[pyo3(name = "circumsphere")]
-fn py_circumsphere(
-    py: Python<'_>,
-    points: &Bound<'_, PyAny>,
-) -> PyResult<(Py<PyTuple>, f64)> {
+fn py_circumsphere(py: Python<'_>, points: &Bound<'_, PyAny>) -> PyResult<(Py<PyTuple>, f64)> {
     let points = parse_points_sized(points, "Please provide a 2-dimensional list of points")?;
-    let (center, radius) = geom::circumsphere(&points).map_err(|err| PyValueError::new_err(err.to_string()))?;
+    let (center, radius) =
+        geom::circumsphere(&points).map_err(|err| PyValueError::new_err(err.to_string()))?;
     Ok((point_tuple(py, &center), radius))
 }