diff -r 495448cca603 -r 6aa955ad8122 src/euclidean.rs
--- a/src/euclidean.rs	Thu May 01 08:40:33 2025 -0500
+++ b/src/euclidean.rs	Thu May 01 13:06:58 2025 -0500
@@ -2,31 +2,37 @@
 Euclidean spaces.
 */
 
-use std::ops::{Mul, MulAssign, Div, DivAssign, Add, Sub, AddAssign, SubAssign, Neg};
-use crate::types::*;
 use crate::instance::Instance;
 use crate::norms::{HasDual, Reflexive};
+use crate::types::*;
+use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
 /// Space (type) with Euclidean and vector space structure
 ///
 /// The type should implement vector space operations (addition, subtraction, scalar
 /// multiplication and scalar division) along with their assignment versions, as well
 /// as an inner product.
-pub trait Euclidean<F : Float> : HasDual<F, DualSpace=Self> + Reflexive<F>
-    + Mul<F, Output=<Self as Euclidean<F>>::Output> + MulAssign<F>
-    + Div<F, Output=<Self as Euclidean<F>>::Output> + DivAssign<F>
-    + Add<Self, Output=<Self as Euclidean<F>>::Output>
-    + Sub<Self, Output=<Self as Euclidean<F>>::Output>
-    + for<'b> Add<&'b Self, Output=<Self as Euclidean<F>>::Output>
-    + for<'b> Sub<&'b Self, Output=<Self as Euclidean<F>>::Output>
-    + AddAssign<Self> + for<'b> AddAssign<&'b Self>
-    + SubAssign<Self> + for<'b> SubAssign<&'b Self>
-    + Neg<Output=<Self as Euclidean<F>>::Output>
+pub trait Euclidean<F: Float = f64>:
+    HasDual<F, DualSpace = Self>
+    + Reflexive<F>
+    + Mul<F, Output = <Self as Euclidean<F>>::Output>
+    + MulAssign<F>
+    + Div<F, Output = <Self as Euclidean<F>>::Output>
+    + DivAssign<F>
+    + Add<Self, Output = <Self as Euclidean<F>>::Output>
+    + Sub<Self, Output = <Self as Euclidean<F>>::Output>
+    + for<'b> Add<&'b Self, Output = <Self as Euclidean<F>>::Output>
+    + for<'b> Sub<&'b Self, Output = <Self as Euclidean<F>>::Output>
+    + AddAssign<Self>
+    + for<'b> AddAssign<&'b Self>
+    + SubAssign<Self>
+    + for<'b> SubAssign<&'b Self>
+    + Neg<Output = <Self as Euclidean<F>>::Output>
 {
-    type Output : Euclidean<F>;
+    type Output: Euclidean<F>;
 
     // Inner product
-    fn dot<I : Instance<Self>>(&self, other : I) -> F;
+    fn dot<I: Instance<Self>>(&self, other: I) -> F;
 
     /// Calculate the square of the 2-norm, $\frac{1}{2}\\|x\\|_2^2$, where `self` is $x$.
     ///
@@ -38,7 +44,7 @@
     /// where `self` is $x$.
     #[inline]
     fn norm2_squared_div2(&self) -> F {
-        self.norm2_squared()/F::TWO
+        self.norm2_squared() / F::TWO
     }
 
     /// Calculate the 2-norm $‖x‖_2$, where `self` is $x$.
@@ -48,33 +54,33 @@
     }
 
     /// Calculate the 2-distance squared $\\|x-y\\|_2^2$, where `self` is $x$.
-    fn dist2_squared<I : Instance<Self>>(&self, y : I) -> F;
+    fn dist2_squared<I: Instance<Self>>(&self, y: I) -> F;
 
     /// Calculate the 2-distance $\\|x-y\\|_2$, where `self` is $x$.
     #[inline]
-    fn dist2<I : Instance<Self>>(&self, y : I) -> F {
+    fn dist2<I: Instance<Self>>(&self, y: I) -> F {
         self.dist2_squared(y).sqrt()
     }
 
     /// Projection to the 2-ball.
     #[inline]
-    fn proj_ball2(mut self, ρ : F) -> Self {
+    fn proj_ball2(mut self, ρ: F) -> Self {
         self.proj_ball2_mut(ρ);
         self
     }
 
     /// In-place projection to the 2-ball.
     #[inline]
-    fn proj_ball2_mut(&mut self, ρ : F) {
+    fn proj_ball2_mut(&mut self, ρ: F) {
         let r = self.norm2();
-        if r>ρ {
-            *self *= ρ/r
+        if r > ρ {
+            *self *= ρ / r
         }
     }
 }
 
 /// Trait for [`Euclidean`] spaces with dimensions known at compile time.
-pub trait StaticEuclidean<F : Float> : Euclidean<F> {
+pub trait StaticEuclidean<F: Float = f64>: Euclidean<F> {
     /// Returns the origin
     fn origin() -> <Self as Euclidean<F>>::Output;
 }