Use Rust formatting

src/bin/flat/main.rs

@@ -241,7 +241,7 @@ impl Space {
 						rot: self.global_to_flat(pos) * rot,
 					}
 				}
-				Boundary => panic!("Object at {} was destroyed by the space curvature", pos),
+				Boundary => panic!("Object at {pos} was destroyed by the space curvature"),
 			})
 	}
 
@@ -690,7 +690,7 @@ mod fns {
 				}
 				let df_num = (testee.value(x + δ) - testee.value(x - δ)) / (2. * δ);
 				let df_expl = testee.derivative(x);
-				assert!(abs_diff_eq!(df_expl, df_num, epsilon = ε), "At x={}, df/dx:\nnumerical: {}\nexplicit:  {}\n", x, df_num, df_expl);
+				assert!(abs_diff_eq!(df_expl, df_num, epsilon = ε), "At x={x}, df/dx:\nnumerical: {df_num}\nexplicit:  {df_expl}\n");
 			}
 		}
 
@@ -708,30 +708,30 @@ mod fns {
 			for x in itertools_num::linspace(-mul * testee.external, mul * testee.external, 100) {
 				let ux = testee.u(x);
 				let xux = testee.x(ux);
-				assert!(abs_diff_eq!(x, xux, epsilon = ε), "At x={}:\nu(x):    {}\nx(u(x)): {}\n", x, ux, xux);
+				assert!(abs_diff_eq!(x, xux, epsilon = ε), "At x={x}:\nu(x):    {ux}\nx(u(x)): {xux}\n");
 
 				let du_num = (testee.u(x + δ) - testee.u(x - δ)) / (2. * δ);
 				let du_expl = testee.du(x);
-				assert!(abs_diff_eq!(du_expl, du_num, epsilon = ε), "At x={}, du/dx:\nnumerical: {}\nexplicit:  {}\n", x, du_num, du_expl);
+				assert!(abs_diff_eq!(du_expl, du_num, epsilon = ε), "At x={x}, du/dx:\nnumerical: {du_num}\nexplicit:  {du_expl}\n");
 
 				let dudx = du_expl * testee.dx(ux);
-				assert!(abs_diff_eq!(dudx, 1.0, epsilon = ε), "At x={}:\ndu/dx * dx/du: {}\n", x, dudx);
+				assert!(abs_diff_eq!(dudx, 1.0, epsilon = ε), "At x={x}:\ndu/dx * dx/du: {dudx}\n");
 
 				let d2u_num = (testee.du(x + δ) - testee.du(x - δ)) / (2. * δ);
 				let d2u_expl = testee.d2u(x);
-				assert!(abs_diff_eq!(d2u_expl, d2u_num, epsilon = ε), "At x={}, d^2u/dx^2:\nnumerical: {}\nexplicit:  {}\n", x, d2u_num, d2u_expl);
+				assert!(abs_diff_eq!(d2u_expl, d2u_num, epsilon = ε), "At x={x}, d^2u/dx^2:\nnumerical: {d2u_num}\nexplicit:  {d2u_expl}\n");
 			}
 			for u in itertools_num::linspace(-mul * testee.internal, mul * testee.internal, 100) {
 				let xu = testee.x(u);
 				let uxu = testee.u(xu);
-				assert!(abs_diff_eq!(u, uxu, epsilon = ε), "At u={}:\nx(u):    {}\nu(x(u)): {}\n", u, xu, uxu);
+				assert!(abs_diff_eq!(u, uxu, epsilon = ε), "At u={u}:\nx(u):    {xu}\nu(x(u)): {uxu}\n");
 
 				let dx_num = (testee.x(u + δ) - testee.x(u - δ)) / (2. * δ);
 				let dx_expl = testee.dx(u);
-				assert!(abs_diff_eq!(dx_expl, dx_num, epsilon = ε), "At u={}, dx/du:\nnumerical: {}\nexplicit:  {}\n", u, dx_num, dx_expl);
+				assert!(abs_diff_eq!(dx_expl, dx_num, epsilon = ε), "At u={u}, dx/du:\nnumerical: {dx_num}\nexplicit:  {dx_expl}\n");
 
 				let dudx = testee.du(xu) * dx_expl;
-				assert!(abs_diff_eq!(dudx, 1.0, epsilon = ε), "At u={}:\ndu/dx * dx/du: {}\n", u, dudx);
+				assert!(abs_diff_eq!(dudx, 1.0, epsilon = ε), "At u={u}:\ndu/dx * dx/du: {dudx}\n");
 			}
 		}
 	}
@@ -798,7 +798,7 @@ fn test_tube_metric_derivs() {
 			let computed = testee.part_derivs_at(pos);
 			let reference = approx.part_derivs_at(pos);
 			let eq = (0..2).all(|coord| computed[coord].abs_diff_eq(reference[coord], epsilon));
-			assert!(eq, "Bad derivative computation at {}:\n  explicit:  {:?}\n  numerical: {:?}\n", pos, computed, reference);
+			assert!(eq, "Bad derivative computation at {pos}:\n  explicit:  {computed:?}\n  numerical: {reference:?}\n");
 		}
 	}
 }