diff -r 0a689881b0f1 -r 8264d72aa347 src/sets.rs
--- a/src/sets.rs	Mon May 12 16:28:50 2025 -0500
+++ b/src/sets.rs	Mon May 12 17:10:39 2025 -0500
@@ -72,22 +72,20 @@
 /// The halfspace is $H = \\{ t v + a \mid a^⊤ v = 0 \\}$, where $v$ is the orthogonal
 /// vector and $t$ the offset.
 #[derive(Clone, Copy, Debug, Serialize, Eq, PartialEq)]
-pub struct Halfspace<A, F>
+pub struct Halfspace<A>
 where
-    A: Euclidean<F>,
-    F: Float,
+    A: Euclidean,
 {
     pub orthogonal: A,
-    pub offset: F,
+    pub offset: A::Field,
 }
 
-impl<A, F> Halfspace<A, F>
+impl<A> Halfspace<A>
 where
-    A: Euclidean<F>,
-    F: Float,
+    A: Euclidean,
 {
     #[inline]
-    pub fn new(orthogonal: A, offset: F) -> Self {
+    pub fn new(orthogonal: A, offset: A::Field) -> Self {
         Halfspace {
             orthogonal: orthogonal,
             offset: offset,
@@ -96,29 +94,26 @@
 }
 
 /// Trait for generating a halfspace spanned by another set `Self` of elements of type `U`.
-pub trait SpannedHalfspace<F>
-where
-    F: Float,
-{
+pub trait SpannedHalfspace {
     /// Type of the orthogonal vector describing the halfspace.
-    type A: Euclidean<F>;
+    type A: Euclidean;
     /// Returns the halfspace spanned by this set.
-    fn spanned_halfspace(&self) -> Halfspace<Self::A, F>;
+    fn spanned_halfspace(&self) -> Halfspace<Self::A>;
 }
 
 // TODO: Gram-Schmidt for higher N.
-impl<F: Float> SpannedHalfspace<F> for [Loc<1, F>; 2] {
+impl<F: Float> SpannedHalfspace for [Loc<1, F>; 2] {
     type A = Loc<1, F>;
-    fn spanned_halfspace(&self) -> Halfspace<Self::A, F> {
+    fn spanned_halfspace(&self) -> Halfspace<Self::A> {
         let (x0, x1) = (self[0], self[1]);
         Halfspace::new(x1 - x0, x0[0])
     }
 }
 
 // TODO: Gram-Schmidt for higher N.
-impl<F: Float> SpannedHalfspace<F> for [Loc<2, F>; 2] {
+impl<F: Float> SpannedHalfspace for [Loc<2, F>; 2] {
     type A = Loc<2, F>;
-    fn spanned_halfspace(&self) -> Halfspace<Self::A, F> {
+    fn spanned_halfspace(&self) -> Halfspace<Self::A> {
         let (x0, x1) = (&self[0], &self[1]);
         let d = x1 - x0;
         let orthog = loc![d[1], -d[0]]; // We don't normalise for efficiency
@@ -127,10 +122,9 @@
     }
 }
 
-impl<A, F> Set<A> for Halfspace<A, F>
+impl<A> Set<A> for Halfspace<A>
 where
-    A: Euclidean<F>,
-    F: Float,
+    A: Euclidean,
 {
     #[inline]
     fn contains<I: Instance<A>>(&self, item: I) -> bool {
@@ -139,17 +133,10 @@
 }
 
 /// Polygons defined by `N` `Halfspace`s.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub struct NPolygon<A, const N: usize, F = f64>(pub [Halfspace<A, F>; N])
-where
-    A: Euclidean<F>,
-    F: Float;
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct NPolygon<A: Euclidean, const N: usize>(pub [Halfspace<A>; N]);
 
-impl<A, F, const N: usize> Set<A> for NPolygon<A, N, F>
-where
-    A: Euclidean<F>,
-    F: Float,
-{
+impl<A: Euclidean, const N: usize> Set<A> for NPolygon<A, N> {
     fn contains<I: Instance<A>>(&self, item: I) -> bool {
         let r = item.ref_instance();
         self.0.iter().all(|halfspace| halfspace.contains(r))