From c89b6d46ff9fce721d08eaa6818a8b4e269ce3f4 Mon Sep 17 00:00:00 2001
From: Rouven Spreckels <rs@qu1x.dev>
Date: Fri, 22 Mar 2024 17:09:38 +0100
Subject: [PATCH] Lower trait bounds on `Ball` and `Enclosing`.

---
 Cargo.toml       |  2 +-
 RELEASES.md      |  6 +++++-
 src/ball.rs      | 18 +++++++++---------
 src/enclosing.rs | 26 +++++++++++++++++++-------
 src/ovec.rs      |  1 -
 5 files changed, 34 insertions(+), 19 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index be2e2c2..c18aa00 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,7 +2,7 @@
 name = "miniball"
 description = "Minimum enclosing ball"
 authors = ["Rouven Spreckels <rs@qu1x.dev>"]
-version = "0.3.0"
+version = "0.3.1"
 rust-version = "1.61.0"
 edition = "2021"
 documentation = "https://docs.rs/miniball"
diff --git a/RELEASES.md b/RELEASES.md
index 587b791..855f878 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -1,6 +1,10 @@
+# Version 0.3.1 (2024-03-22)
+
+  * Lower trait bounds on `Ball` and `Enclosing`.
+
 # Version 0.3.0 (2024-03-17)
 
-  * Replace `Point` with `OPoint` supporting static as well as dynamic dimensions.
+  * Replace `Point` with `OPoint` supporting arithmetic at compile-time.
   * Replace `ArrayVec<T, { D + 1 }>` with `OVec<T, DimNameSum<D, U1>>` supporting stabe Rust.
 
 # Version 0.2.0 (2023-04-01)
diff --git a/src/ball.rs b/src/ball.rs
index ceb386e..c729d6d 100644
--- a/src/ball.rs
+++ b/src/ball.rs
@@ -6,13 +6,12 @@
 
 use super::Enclosing;
 use nalgebra::{
-	base::allocator::Allocator, DefaultAllocator, DimNameAdd, DimNameSum, OMatrix, OPoint, OVector,
-	RealField, U1,
+	base::allocator::Allocator, DefaultAllocator, DimName, OMatrix, OPoint, OVector, RealField,
 };
 
 /// Ball over real field `R` of dimension `D` with center and radius squared.
 #[derive(Debug, Clone, PartialEq)]
-pub struct Ball<R: RealField, D: DimNameAdd<U1>>
+pub struct Ball<R: RealField, D: DimName>
 where
 	DefaultAllocator: Allocator<R, D>,
 {
@@ -22,24 +21,25 @@ where
 	pub radius_squared: R,
 }
 
-impl<R: RealField + Copy, D: DimNameAdd<U1>> Copy for Ball<R, D>
+impl<R: RealField + Copy, D: DimName> Copy for Ball<R, D>
 where
 	OPoint<R, D>: Copy,
 	DefaultAllocator: Allocator<R, D>,
 {
 }
 
-impl<R: RealField, D: DimNameAdd<U1>> Enclosing<R, D> for Ball<R, D>
+impl<R: RealField, D: DimName> Enclosing<R, D> for Ball<R, D>
 where
-	DefaultAllocator:
-		Allocator<R, D> + Allocator<R, D, D> + Allocator<OPoint<R, D>, DimNameSum<D, U1>>,
-	<DefaultAllocator as Allocator<OPoint<R, D>, DimNameSum<D, U1>>>::Buffer: Default,
+	DefaultAllocator: Allocator<R, D>,
 {
 	#[inline]
 	fn contains(&self, point: &OPoint<R, D>) -> bool {
 		(point - &self.center).norm_squared() <= self.radius_squared
 	}
-	fn with_bounds(bounds: &[OPoint<R, D>]) -> Option<Self> {
+	fn with_bounds(bounds: &[OPoint<R, D>]) -> Option<Self>
+	where
+		DefaultAllocator: Allocator<R, D, D>,
+	{
 		let length = bounds.len().checked_sub(1).filter(|&len| len <= D::USIZE)?;
 		let points = OMatrix::<R, D, D>::from_fn(|row, column| {
 			if column < length {
diff --git a/src/enclosing.rs b/src/enclosing.rs
index 46fd053..56f515e 100644
--- a/src/enclosing.rs
+++ b/src/enclosing.rs
@@ -6,17 +6,17 @@
 
 use super::{Deque, OVec};
 use nalgebra::{
-	base::allocator::Allocator, DefaultAllocator, DimNameAdd, DimNameSum, OPoint, RealField, U1,
+	base::allocator::Allocator, DefaultAllocator, DimName, DimNameAdd, DimNameSum, OPoint,
+	RealField, U1,
 };
 use stacker::maybe_grow;
 use std::mem::size_of;
 
 /// Minimum enclosing ball.
-pub trait Enclosing<R: RealField, D: DimNameAdd<U1>>
+pub trait Enclosing<R: RealField, D: DimName>
 where
 	Self: Clone,
-	DefaultAllocator: Allocator<R, D> + Allocator<OPoint<R, D>, DimNameSum<D, U1>>,
-	<DefaultAllocator as Allocator<OPoint<R, D>, DimNameSum<D, U1>>>::Buffer: Default,
+	DefaultAllocator: Allocator<R, D>,
 {
 	#[doc(hidden)]
 	/// Guaranteed stack size per recursion step.
@@ -59,7 +59,9 @@ where
 	/// assert_eq!(radius_squared, 3.0);
 	/// ```
 	#[must_use]
-	fn with_bounds(bounds: &[OPoint<R, D>]) -> Option<Self>;
+	fn with_bounds(bounds: &[OPoint<R, D>]) -> Option<Self>
+	where
+		DefaultAllocator: Allocator<R, D, D>;
 
 	/// Returns minimum ball enclosing `points`.
 	///
@@ -130,7 +132,12 @@ where
 	/// ```
 	#[must_use]
 	#[inline]
-	fn enclosing_points(points: &mut impl Deque<OPoint<R, D>>) -> Self {
+	fn enclosing_points(points: &mut impl Deque<OPoint<R, D>>) -> Self
+	where
+		D: DimNameAdd<U1>,
+		DefaultAllocator: Allocator<R, D, D> + Allocator<OPoint<R, D>, DimNameSum<D, U1>>,
+		<DefaultAllocator as Allocator<OPoint<R, D>, DimNameSum<D, U1>>>::Buffer: Default,
+	{
 		maybe_grow(Self::RED_ZONE, Self::STACK_SIZE, || {
 			Self::enclosing_points_with_bounds(
 				points,
@@ -147,7 +154,12 @@ where
 	fn enclosing_points_with_bounds(
 		points: &mut impl Deque<OPoint<R, D>>,
 		bounds: &mut OVec<OPoint<R, D>, DimNameSum<D, U1>>,
-	) -> Option<Self> {
+	) -> Option<Self>
+	where
+		D: DimNameAdd<U1>,
+		DefaultAllocator: Allocator<R, D, D> + Allocator<OPoint<R, D>, DimNameSum<D, U1>>,
+		<DefaultAllocator as Allocator<OPoint<R, D>, DimNameSum<D, U1>>>::Buffer: Default,
+	{
 		// Take point from back.
 		if let Some(point) = points.pop_back().filter(|_| !bounds.is_full()) {
 			let ball = maybe_grow(Self::RED_ZONE, Self::STACK_SIZE, || {
diff --git a/src/ovec.rs b/src/ovec.rs
index cbc5a2c..cfb956d 100644
--- a/src/ovec.rs
+++ b/src/ovec.rs
@@ -61,7 +61,6 @@ where
 	/// Panics if [`Self::is_full()`].
 	#[inline]
 	pub fn push(&mut self, item: T) {
-		assert!(!self.is_full());
 		self.data[self.size] = item;
 		self.size += 1;
 	}