Simplify some type conversions

w1th0utnam3 · w1th0utnam3 · commit af750a6dbfec · 2025-06-12T09:39:53.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/pysplashsurf/src/pipeline.rs b/pysplashsurf/src/pipeline.rs
@@ -124,7 +124,7 @@ fn reconstruction_pipeline_generic<I: Index, R: Real>(
 
             let particle_rest_density = rest_density;
             let particle_rest_volume =
-                R::from_f64((4.0 / 3.0) * std::f64::consts::PI).unwrap() * particle_radius.powi(3);
+                R::from_float(4.0) * R::frac_pi_3() * particle_radius.powi(3);
             let particle_rest_mass = particle_rest_volume * particle_rest_density;
 
             let particle_densities = reconstruction
diff --git a/splashsurf/src/reconstruction.rs b/splashsurf/src/reconstruction.rs
@@ -999,8 +999,8 @@ pub(crate) fn reconstruction_pipeline_generic<I: Index, R: Real>(
             );
 
             let particle_rest_density = params.rest_density;
-            let particle_rest_volume = R::from_f64((4.0 / 3.0) * std::f64::consts::PI).unwrap()
-                * params.particle_radius.powi(3);
+            let particle_rest_volume =
+                R::from_float(4.0) * R::frac_pi_3() * params.particle_radius.powi(3);
             let particle_rest_mass = particle_rest_volume * particle_rest_density;
 
             let particle_densities = reconstruction
diff --git a/splashsurf_lib/Cargo.toml b/splashsurf_lib/Cargo.toml
@@ -33,6 +33,7 @@ io = ["vtk_extras", "vtkio", "ply-rs", "nom", "serde_json", "flate2"]
 [dependencies]
 log = "0.4"
 nalgebra = { version = "0.33", features = ["rand", "bytemuck"] }
+simba = "0.9.0"
 num-traits = "0.2"
 num-integer = "0.1"
 anyhow = "1.0"
diff --git a/splashsurf_lib/src/dense_subdomains.rs b/splashsurf_lib/src/dense_subdomains.rs
@@ -62,7 +62,7 @@ pub(crate) struct ParametersSubdomainGrid<I: Index, R: Real> {
     surface_threshold: R,
     /// MC cube size (in simulation units)
     cube_size: R,
-    /// Size of a subdomain in multiplies of MC cubes
+    /// Size of a subdomain in multiples of MC cubes
     subdomain_cubes: I,
     /// Margin for ghost particles around each subdomain
     ghost_particle_margin: R,
@@ -130,7 +130,7 @@ pub(crate) fn initialize_parameters<I: Index, R: Real>(
     let cube_size = parameters.cube_size;
     let surface_threshold = parameters.iso_surface_threshold;
 
-    let particle_rest_volume = to_real!(4) * R::frac_pi_3() * particle_radius.powi(3);
+    let particle_rest_volume = R::from_float(4.0) * R::frac_pi_3() * particle_radius.powi(3);
     let particle_rest_mass = particle_rest_volume * particle_rest_density;
 
     let ghost_particle_margin =
diff --git a/splashsurf_lib/src/io/bgeo_format.rs b/splashsurf_lib/src/io/bgeo_format.rs
@@ -45,11 +45,8 @@ pub fn particles_from_bgeo_file<R: Real>(
     };
 
     // Convert the array storage into individual vectors
-    let positions: Vec<_> = position_storage
-        .chunks(3)
-        .map(|p| Vector3::new(p[0], p[1], p[2]).try_convert().unwrap())
-        .collect();
-
+    let positions: Vec<_> =
+        io_utils::try_convert_scalar_slice_to_vectors(position_storage, |v| v.try_convert())?;
     Ok(positions)
 }
 
diff --git a/splashsurf_lib/src/kernel.rs b/splashsurf_lib/src/kernel.rs
@@ -26,7 +26,7 @@ pub struct CubicSplineKernel<R: Real> {
 
 impl<R: Real> CubicSplineKernel<R> {
     /// Initializes a cubic spline kernel with the given compact support radius
-    #[replace_float_literals(R::from_f64(literal).expect("Literal must fit in R"))]
+    #[replace_float_literals(R::from_float(literal))]
     pub fn new(compact_support_radius: R) -> Self {
         let h = compact_support_radius;
         let sigma = 8.0 / (h * h * h);
@@ -38,7 +38,7 @@ impl<R: Real> CubicSplineKernel<R> {
     }
 
     /// The cubic spline function used by the cubic spline kernel
-    #[replace_float_literals(R::from_f64(literal).expect("Literal must fit in R"))]
+    #[replace_float_literals(R::from_float(literal))]
     fn cubic_function(q: R) -> R {
         if q < R::one() {
             (3.0 / (2.0 * R::pi())) * ((2.0 / 3.0) - q * q + 0.5 * q * q * q)
@@ -51,7 +51,7 @@ impl<R: Real> CubicSplineKernel<R> {
     }
 
     /// The derivative of the cubic spline function used by the cubic spline kernel w.r.t to the parameter `q`
-    #[replace_float_literals(R::from_f64(literal).expect("Literal must fit in R"))]
+    #[replace_float_literals(R::from_float(literal))]
     fn cubic_function_dq(q: R) -> R {
         if q < 1.0 {
             (3.0 / (4.0 * R::pi())) * (-4.0 * q + 3.0 * q * q)
diff --git a/splashsurf_lib/src/marching_cubes.rs b/splashsurf_lib/src/marching_cubes.rs
@@ -167,7 +167,7 @@ pub fn check_mesh_consistency<I: Index, R: Real>(
                 .get_point(*cell_index.index())
                 .expect("Unable to get point index of cell");
             let cell_center = grid.point_coordinates(&point_index)
-                + Vector3::repeat(grid.cell_size().times_f64(0.5));
+                + Vector3::repeat(grid.cell_size() * R::from_float(0.5));
 
             error_strings.push(format!("\tTriangle {}, boundary edge {:?} is located in cell with {:?} with center coordinates {:?} and edge length {}.", tri_idx, edge, cell_index, cell_center, grid.cell_size()));
         } else {
@@ -246,7 +246,7 @@ fn check_mesh_with_cell_data<I: Index, R: Real>(
                 .get_point(*cell_index.index())
                 .expect("Unable to get point index of cell");
             let cell_center = grid.point_coordinates(&point_index)
-                + Vector3::repeat(grid.cell_size().times_f64(0.5));
+                + Vector3::repeat(grid.cell_size() * R::from_float(0.5));
 
             let cell_data = marching_cubes_data
                 .cell_data
diff --git a/splashsurf_lib/src/postprocessing.rs b/splashsurf_lib/src/postprocessing.rs
@@ -12,7 +12,7 @@ use rayon::prelude::*;
 /// Laplacian Smoothing with feature weights
 ///
 /// Move each vertex towards the mean position of its neighbors.
-/// Factor beta in \[0;1] proportional to amount of smoothing (for beta=1 each vertex is placed at the mean position).
+/// Factor beta in \[0;1] proportional to the amount of smoothing (for beta=1 each vertex is placed at the mean position).
 /// Additionally, feature weights can be specified to apply a varying amount of smoothing over the mesh.
 pub fn par_laplacian_smoothing_inplace<R: Real>(
     mesh: &mut TriMesh3d<R>,
@@ -668,7 +668,7 @@ pub fn convert_tris_to_quads<R: Real>(
 
     let min_dot = normal_angle_limit_rad.cos();
     let max_non_squareness = non_squareness_limit;
-    let sqrt_two = R::from_f64(2.0_f64.sqrt()).unwrap();
+    let sqrt_two = R::from_float(2.0_f64.sqrt());
 
     let tris_to_quad = |tri_i: &[usize; 3], tri_j: &[usize; 3]| -> [usize; 4] {
         let mut quad = [0, 0, 0, 0];
diff --git a/splashsurf_lib/src/reconstruction.rs b/splashsurf_lib/src/reconstruction.rs
@@ -6,7 +6,7 @@ use crate::mesh::TriMesh3d;
 use crate::uniform_grid::UniformGrid;
 use crate::workspace::LocalReconstructionWorkspace;
 use crate::{
-    Index, Parameters, Real, ReconstructionError, SurfaceReconstruction, density_map,
+    Index, Parameters, Real, RealConvert, ReconstructionError, SurfaceReconstruction, density_map,
     marching_cubes, neighborhood_search, profile,
 };
 use anyhow::Context;
@@ -120,8 +120,8 @@ pub(crate) fn compute_particle_densities_and_neighbors<I: Index, R: Real>(
     profile!("compute_particle_densities_and_neighbors");
 
     let particle_rest_density = parameters.rest_density;
-    let particle_rest_volume = R::from_f64((4.0 / 3.0) * std::f64::consts::PI).unwrap()
-        * parameters.particle_radius.powi(3);
+    let particle_rest_volume =
+        R::from_float(4.0) * R::frac_pi_3() * parameters.particle_radius.powi(3);
     let particle_rest_mass = particle_rest_volume * particle_rest_density;
 
     trace!("Starting neighborhood search...");
@@ -153,8 +153,8 @@ pub(crate) fn reconstruct_single_surface_append<I: Index, R: Real>(
     output_mesh: &mut TriMesh3d<R>,
 ) -> Result<(), ReconstructionError<I, R>> {
     let particle_rest_density = parameters.rest_density;
-    let particle_rest_volume = R::from_f64((4.0 / 3.0) * std::f64::consts::PI).unwrap()
-        * parameters.particle_radius.powi(3);
+    let particle_rest_volume =
+        R::from_float(4.0) * R::frac_pi_3() * parameters.particle_radius.powi(3);
     let particle_rest_mass = particle_rest_volume * particle_rest_density;
 
     let particle_densities = {
diff --git a/splashsurf_lib/src/traits.rs b/splashsurf_lib/src/traits.rs
@@ -4,6 +4,7 @@ use num_integer::Integer;
 use num_traits::{
     Bounded, CheckedAdd, CheckedMul, CheckedSub, FromPrimitive, NumCast, SaturatingSub, ToPrimitive,
 };
+use simba::scalar::SupersetOf;
 use std::fmt::{Debug, Display};
 use std::hash::Hash;
 use std::ops::{AddAssign, MulAssign, SubAssign};
@@ -102,19 +103,27 @@ pub trait Index:
 
 /// Trait that has to be implemented for types to be used as floating points values in the context of the library (e.g. for coordinates, density values)
 pub trait Real:
-RealField
-// Required by RStar and not part of RealFied anymore
-+ Bounded
-// Not part of RealField anymore
-+ Copy
-+ FromPrimitive
-+ ToPrimitive
-+ NumCast
-+ Debug
-+ Default
-+ Pod
-+ ThreadSafe
+    RealField
+    // Required by RStar and not part of RealFied anymore
+    + Bounded
+    // Not part of RealField anymore
+    + Copy
+    + FromPrimitive
+    + ToPrimitive
+    + NumCast
+    + Debug
+    + Default
+    + Pod
+    + ThreadSafe
 {
+    /// Converts the given float value to this Real type
+    #[inline]
+    fn from_float<T>(value: T) -> Self
+    where Self: SupersetOf<T> 
+    {
+        Self::from_subset(&value)
+    }
+    
     /// Converts this value to the specified [`Index`] type. If the value cannot be represented by the target type, `None` is returned.
     fn to_index<I: Index>(self) -> Option<I> {
         I::from_f64(self.to_f64()?)
@@ -129,15 +138,10 @@ RealField
     fn times(self, n: i32) -> Self {
         self.mul(Self::from_i32(n).unwrap())
     }
-
-    /// Multiplies this value by the specified `f64` coefficient. Panics if the coefficient cannot be converted into the target type.
-    fn times_f64(self, x: f64) -> Self {
-        self.mul(Self::from_f64(x).unwrap())
-    }
 }
 
-impl<T> Index for T where
-    T: Copy
+impl<I> Index for I where
+    I: Copy
         + Hash
         + Integer
         + Bounded
@@ -160,8 +164,8 @@ impl<T> Index for T where
 {
 }
 
-impl<
-    T: RealField
+impl<R> Real for R where
+    R: RealField
         + Bounded
         + Copy
         + FromPrimitive
@@ -171,8 +175,7 @@ impl<
         + Default
         + Pod
         + ThreadSafe
-        + 'static,
-> Real for T
+        + 'static
 {
 }
 
@@ -185,6 +188,7 @@ pub trait RealConvert: Sized {
     /// Tries to convert this value to the target type, returns `None` if value cannot be represented by the target type
     fn try_convert<To: Real>(self) -> Option<Self::Out<To>>;
     /// Converts this value to the target type, panics if value cannot be represented by the target type
+    #[inline]
     fn convert<To: Real>(self) -> Self::Out<To> {
         self.try_convert().expect("failed to convert")
     }
@@ -196,6 +200,7 @@ impl<From: Real> RealConvert for &From {
     where
         To: Real;
 
+    #[inline]
     fn try_convert<To: Real>(self) -> Option<To> {
         <To as NumCast>::from(*self)
     }
@@ -207,6 +212,7 @@ impl<From: Real, const R: usize, const C: usize> RealConvert for SMatrix<From, R
     where
         To: Real;
 
+    #[inline]
     fn try_convert<To: Real>(self) -> Option<SMatrix<To, R, C>> {
         let mut m_out: SMatrix<To, R, C> = SMatrix::zeros();
         m_out
