eat(deep_causality_num): Introduce generic FloatOption trait

Introduces a new `FloatOption<F>` trait to abstract over float types (
      `f32`, `f64`) and their `Option` variants. This trait provides a
      unified `to_option()` method that converts the implementing type into
      an `Option<F>`, treating `NaN` values as `None`.

This change enables generic programming for algorithms that need to
      handle both concrete float values and optional/missing float values,
      reducing code duplication in dependent crates.

Signed-off-by: Marvin Hansen <[email protected]>

Author: marvin-hansen

deep_causality_num/src/types/float/float_32_impl.rs renamed to deep_causality_num/src/float/float_32_impl.rs

@@ -0,0 +1,41 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+
+use crate::Float;
+use std::fmt::Debug;
+
+/// A trait to abstract over float types (`f32`, `f64`) and their `Option` variants.
+///
+/// It provides a unified way to convert these types into an `Option<F>`
+/// where `F` is a type that implements the `Float` trait.
+pub trait FloatOption<F: Float>: Clone + Debug + Send + Sync + 'static {
+    /// Converts the implementing type into an `Option<F>`.
+    ///
+    /// - For a float type `F`, `NaN` is treated as a missing value (`None`).
+    /// - For `Option<F>`, this handles `Some(NaN)` by returning `None`, and passes through `Some(value)` and `None`.
+    fn to_option(&self) -> Option<F>;
+}
+
+// Implementation for any `F` that implements `Float`.
+// This covers `f32` and `f64`.
+impl<F> FloatOption<F> for F
+where
+    F: Float + Debug + Send + Sync + 'static,
+{
+    fn to_option(&self) -> Option<F> {
+        if self.is_nan() { None } else { Some(*self) }
+    }
+}
+
+// Implementation for `Option<F>`.
+// This covers `Option<f32>` and `Option<f64>`.
+impl<F> FloatOption<F> for Option<F>
+where
+    F: Float + Debug + Send + Sync + 'static,
+{
+    fn to_option(&self) -> Option<F> {
+        self.and_then(|value| if value.is_nan() { None } else { Some(value) })
+    }
+}

deep_causality_num/src/types/float/float_64_impl.rs renamed to deep_causality_num/src/float/float_64_impl.rs

@@ -1,7 +1,9 @@
 mod cast;
+pub mod float;
+mod float_option;
 mod identity;
+pub mod num;
 mod ops;
-mod types;
 
 pub use crate::cast::as_primitive::AsPrimitive;
 pub use crate::cast::as_scalar::float_as_scalar_impl::FloatAsScalar;
@@ -10,8 +12,9 @@ pub use crate::cast::from_primitive::FromPrimitive;
 pub use crate::cast::num_cast::NumCast;
 pub use crate::cast::to_float::{FloatFromInt, IntoFloat};
 pub use crate::cast::to_primitive::ToPrimitive;
+pub use crate::float::Float;
+pub use crate::float_option::FloatOption;
 pub use crate::identity::one::{ConstOne, One};
 pub use crate::identity::zero::{ConstZero, Zero};
+pub use crate::num::Num;
 pub use crate::ops::num_ops::*;
-pub use crate::types::float::Float;
-pub use crate::types::num::Num;

deep_causality_num/src/types/float/mod.rs renamed to deep_causality_num/src/float/mod.rs

@@ -18,6 +18,22 @@ rust_test_suite(
     ],
 )
 
+rust_test_suite(
+    name = "float",
+    srcs = glob([
+        "float/*_tests.rs",
+        "types/num/*_tests.rs",
+    ]),
+    tags = [
+        "unit-test",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        # Crate to test
+        "//deep_causality_num",
+    ],
+)
+
 rust_test_suite(
     name = "identity",
     srcs = glob([
@@ -34,9 +50,9 @@ rust_test_suite(
 )
 
 rust_test_suite(
-    name = "ops",
+    name = "num",
     srcs = glob([
-        "ops/*_tests.rs",
+        "num/*_tests.rs",
     ]),
     tags = [
         "unit-test",
@@ -49,10 +65,9 @@ rust_test_suite(
 )
 
 rust_test_suite(
-    name = "types",
+    name = "ops",
     srcs = glob([
-        "types/float/*_tests.rs",
-        "types/num/*_tests.rs",
+        "ops/*_tests.rs",
     ]),
     tags = [
         "unit-test",
@@ -62,4 +77,4 @@ rust_test_suite(
         # Crate to test
         "//deep_causality_num",
     ],
-)
+)