(ml5717) Moved RNG into Simulation cog

Author: juntyr

float-next-after-no-std/src/lib.rs

@@ -312,7 +312,7 @@ mod tests_f64 {
             LARGEST_POS,
             LARGEST_NEG,
         ];
-        for x in values {
+        for x in &values {
             assert_eq!(x.next_after(*x), *x);
         }
     }
@@ -455,8 +455,8 @@ mod tests_f32 {
     fn step_to_largest_is_possible() {
         let smaller = LARGEST_POS.next_after(NEG_INF);
         assert_eq!(smaller.next_after(POS_INF), LARGEST_POS);
-        let smaller = LARGEST_NEG.next_after(POS_INF);
-        assert_eq!(smaller.next_after(NEG_INF), LARGEST_NEG);
+        let smaller2 = LARGEST_NEG.next_after(POS_INF);
+        assert_eq!(smaller2.next_after(NEG_INF), LARGEST_NEG);
     }
 
     #[test]
@@ -496,7 +496,7 @@ mod tests_f32 {
             LARGEST_POS,
             LARGEST_NEG,
         ];
-        for x in values {
+        for x in &values {
             assert_eq!(x.next_after(*x), *x);
         }
     }

necsim-classical/src/lib.rs

@@ -6,9 +6,8 @@ extern crate contracts;
 use anyhow::Result;
 use array2d::Array2D;
 
-use necsim_core::cogs::LineageStore;
+use necsim_core::cogs::{LineageStore, RngCore};
 use necsim_core::reporter::Reporter;
-use necsim_core::rng::Rng;
 use necsim_core::simulation::Simulation;
 
 use necsim_impls_no_std::cogs::active_lineage_sampler::classical::ClassicalActiveLineageSampler;
@@ -41,12 +40,12 @@ impl ClassicalSimulation {
         sample_percentage <= 1.0_f64,
         "0.0 <= sample_percentage <= 1.0"
     )]
-    pub fn simulate(
+    pub fn simulate<G: RngCore>(
         habitat: &Array2D<u32>,
         dispersal: &Array2D<f64>,
         speciation_probability_per_generation: f64,
         sample_percentage: f64,
-        rng: &mut impl Rng,
+        rng: G,
         reporter: &mut impl Reporter<InMemoryHabitat, InMemoryLineageReference>,
     ) -> Result<(f64, usize)> {
         let habitat = InMemoryHabitat::new(habitat.clone());
@@ -59,6 +58,7 @@ impl ClassicalSimulation {
         let simulation = Simulation::builder()
             .speciation_probability_per_generation(speciation_probability_per_generation)
             .habitat(habitat)
+            .rng(rng)
             .dispersal_sampler(dispersal_sampler)
             .lineage_reference(std::marker::PhantomData::<InMemoryLineageReference>)
             .lineage_store(lineage_store)
@@ -67,7 +67,7 @@ impl ClassicalSimulation {
             .active_lineage_sampler(active_lineage_sampler)
             .build();
 
-        let (time, steps) = simulation.simulate(rng, reporter);
+        let (time, steps) = simulation.simulate(reporter);
 
         Ok((time, steps))
     }

necsim-core/src/cogs/active_lineage_sampler.rs

@@ -1,20 +1,21 @@
 use super::{
     CoalescenceSampler, DispersalSampler, EventSampler, Habitat, LineageReference, LineageStore,
+    RngCore,
 };
 
 use crate::landscape::Location;
-use crate::rng::Rng;
 use crate::simulation::partial::active_lineager_sampler::PartialSimulation;
 
 #[allow(clippy::inline_always, clippy::inline_fn_without_body)]
 #[contract_trait]
 pub trait ActiveLineageSampler<
     H: Habitat,
-    D: DispersalSampler<H>,
+    G: RngCore,
+    D: DispersalSampler<H, G>,
     R: LineageReference<H>,
     S: LineageStore<H, R>,
-    C: CoalescenceSampler<H, R, S>,
-    E: EventSampler<H, D, R, S, C>,
+    C: CoalescenceSampler<H, G, R, S>,
+    E: EventSampler<H, G, D, R, S, C>,
 >: core::fmt::Debug
 {
     #[must_use]
@@ -43,8 +44,8 @@ pub trait ActiveLineageSampler<
     fn pop_active_lineage_location_event_time(
         &mut self,
         time: f64,
-        simulation: &mut PartialSimulation<H, D, R, S, C, E>,
-        rng: &mut impl Rng,
+        simulation: &mut PartialSimulation<H, G, D, R, S, C, E>,
+        rng: &mut G,
     ) -> Option<(R, Location, f64)>;
 
     #[debug_requires(time >= 0.0_f64, "time is non-negative")]
@@ -57,7 +58,7 @@ pub trait ActiveLineageSampler<
         lineage_reference: R,
         location: Location,
         time: f64,
-        simulation: &mut PartialSimulation<H, D, R, S, C, E>,
-        rng: &mut impl Rng,
+        simulation: &mut PartialSimulation<H, G, D, R, S, C, E>,
+        rng: &mut G,
     );
 }

necsim-core/src/cogs/coalescence_sampler.rs

@@ -1,11 +1,11 @@
+use crate::cogs::RngCore;
 use crate::landscape::Location;
-use crate::rng::Rng;
 
 use super::{Habitat, LineageReference, LineageStore};
 
 #[allow(clippy::inline_always, clippy::inline_fn_without_body)]
 #[contract_trait]
-pub trait CoalescenceSampler<H: Habitat, R: LineageReference<H>, S: LineageStore<H, R>>:
+pub trait CoalescenceSampler<H: Habitat, G: RngCore, R: LineageReference<H>, S: LineageStore<H, R>>:
     core::fmt::Debug
 {
     #[must_use]
@@ -15,6 +15,6 @@ pub trait CoalescenceSampler<H: Habitat, R: LineageReference<H>, S: LineageStore
         location: &Location,
         habitat: &H,
         lineage_store: &S,
-        rng: &mut impl Rng,
+        rng: &mut G,
     ) -> Option<R>;
 }

necsim-core/src/cogs/dispersal_sampler.rs

@@ -1,24 +1,21 @@
+use crate::cogs::RngCore;
 use crate::landscape::Location;
-use crate::rng::Rng;
 
 use super::Habitat;
 
-pub trait DispersalSampler<H: Habitat>: core::fmt::Debug {
+pub trait DispersalSampler<H: Habitat, G: RngCore>: core::fmt::Debug {
     #[must_use]
-    fn sample_dispersal_from_location(&self, location: &Location, rng: &mut impl Rng) -> Location;
+    fn sample_dispersal_from_location(&self, location: &Location, rng: &mut G) -> Location;
 }
 
 #[allow(clippy::inline_always, clippy::inline_fn_without_body)]
 #[allow(clippy::module_name_repetitions)]
 #[contract_trait]
-pub trait SeparableDispersalSampler<H: Habitat>: DispersalSampler<H> {
+pub trait SeparableDispersalSampler<H: Habitat, G: RngCore>: DispersalSampler<H, G> {
     #[must_use]
     #[debug_ensures(&ret != location, "disperses to a different location")]
-    fn sample_non_self_dispersal_from_location(
-        &self,
-        location: &Location,
-        rng: &mut impl Rng,
-    ) -> Location;
+    fn sample_non_self_dispersal_from_location(&self, location: &Location, rng: &mut G)
+        -> Location;
 
     #[must_use]
     #[debug_ensures(ret >= 0.0_f64 && ret <= 1.0_f64, "returns probability")]

necsim-core/src/cogs/event_sampler.rs

@@ -1,19 +1,21 @@
 use float_next_after::NextAfter;
 
-use super::{CoalescenceSampler, DispersalSampler, Habitat, LineageReference, LineageStore};
+use super::{
+    CoalescenceSampler, DispersalSampler, Habitat, LineageReference, LineageStore, RngCore,
+};
 use crate::event::{Event, EventType};
 use crate::landscape::Location;
-use crate::rng::Rng;
 use crate::simulation::partial::event_sampler::PartialSimulation;
 
 #[allow(clippy::inline_always, clippy::inline_fn_without_body)]
 #[contract_trait]
 pub trait EventSampler<
     H: Habitat,
-    D: DispersalSampler<H>,
+    G: RngCore,
+    D: DispersalSampler<H, G>,
     R: LineageReference<H>,
     S: LineageStore<H, R>,
-    C: CoalescenceSampler<H, R, S>,
+    C: CoalescenceSampler<H, G, R, S>,
 >: core::fmt::Debug
 {
     #[must_use]
@@ -34,8 +36,8 @@ pub trait EventSampler<
         lineage_reference: R,
         location: Location,
         event_time: f64,
-        simulation: &PartialSimulation<H, D, R, S, C>,
-        rng: &mut impl Rng,
+        simulation: &PartialSimulation<H, G, D, R, S, C>,
+        rng: &mut G,
     ) -> Event<H, R>;
 
     #[must_use]
@@ -55,9 +57,11 @@ pub trait EventSampler<
         &self,
         lineage_reference: R,
         time: f64,
-        simulation: &PartialSimulation<H, D, R, S, C>,
-        rng: &mut impl Rng,
+        simulation: &PartialSimulation<H, G, D, R, S, C>,
+        rng: &mut G,
     ) -> Event<H, R> {
+        use crate::cogs::RngSampler;
+
         let delta_time =
             rng.sample_exponential(simulation.speciation_probability_per_generation * 0.5_f64);
 

necsim-core/src/cogs/mod.rs

@@ -1,6 +1,9 @@
 mod habitat;
 pub use habitat::Habitat;
 
+mod rng;
+pub use rng::{PrimeableRng, RngCore, RngSampler};
+
 mod dispersal_sampler;
 pub use dispersal_sampler::{DispersalSampler, SeparableDispersalSampler};
 

necsim-core/src/rng.rs renamed to necsim-core/src/cogs/rng.rs

@@ -5,7 +5,7 @@ use core::default::Default;
 use core::ptr::copy_nonoverlapping;
 
 #[allow(clippy::module_name_repetitions)]
-pub trait RngCore: Sized + Clone {
+pub trait RngCore: Sized + Clone + core::fmt::Debug {
     type Seed: AsMut<[u8]> + Default + Sized;
 
     #[must_use]
@@ -46,15 +46,10 @@ pub trait RngCore: Sized + Clone {
     fn sample_u64(&mut self) -> u64;
 }
 
-pub trait IncoherentRngCore: RngCore {
-    type Prime: AsMut<[u8]> + Sized;
-
-    fn prime_with(&mut self, prime: Self::Prime);
-}
-
 #[allow(clippy::inline_always, clippy::inline_fn_without_body)]
+#[allow(clippy::module_name_repetitions)]
 #[contract_trait]
-pub trait Rng: RngCore {
+pub trait RngSampler: RngCore {
     #[must_use]
     #[inline]
     #[debug_ensures(ret >= 0.0_f64 && ret <= 1.0_f64, "samples U(0.0, 1.0)")]
@@ -99,4 +94,11 @@ pub trait Rng: RngCore {
     }
 }
 
-impl<R: RngCore> Rng for R {}
+impl<R: RngCore> RngSampler for R {}
+
+#[allow(clippy::module_name_repetitions)]
+pub trait PrimeableRng: RngCore {
+    type Prime: AsMut<[u8]> + Sized;
+
+    fn prime_with(&mut self, prime: Self::Prime);
+}

necsim-core/src/lib.rs

@@ -25,5 +25,4 @@ pub mod intrinsics;
 pub mod landscape;
 pub mod lineage;
 pub mod reporter;
-pub mod rng;
 pub mod simulation;

necsim-core/src/simulation/builder.rs

@@ -5,12 +5,13 @@ use core::marker::PhantomData;
 
 use crate::cogs::{
     ActiveLineageSampler, CoalescenceSampler, DispersalSampler, EventSampler, Habitat,
-    LineageReference, LineageStore,
+    LineageReference, LineageStore, RngCore,
 };
 
 #[derive(TypedBuilder, Debug)]
 #[cfg_attr(feature = "cuda", derive(RustToCuda, LendToCuda))]
 #[cfg_attr(feature = "cuda", r2cBound(H: rust_cuda::common::RustToCuda))]
+#[cfg_attr(feature = "cuda", r2cBound(G: rust_cuda::common::RustToCuda))]
 #[cfg_attr(feature = "cuda", r2cBound(D: rust_cuda::common::RustToCuda))]
 #[cfg_attr(feature = "cuda", r2cBound(R: rustacuda_core::DeviceCopy))]
 #[cfg_attr(feature = "cuda", r2cBound(S: rust_cuda::common::RustToCuda))]
@@ -19,19 +20,22 @@ use crate::cogs::{
 #[cfg_attr(feature = "cuda", r2cBound(A: rust_cuda::common::RustToCuda))]
 pub struct Simulation<
     H: Habitat,
-    D: DispersalSampler<H>,
+    G: RngCore,
+    D: DispersalSampler<H, G>,
     R: LineageReference<H>,
     S: LineageStore<H, R>,
-    C: CoalescenceSampler<H, R, S>,
-    E: EventSampler<H, D, R, S, C>,
-    A: ActiveLineageSampler<H, D, R, S, C, E>,
+    C: CoalescenceSampler<H, G, R, S>,
+    E: EventSampler<H, G, D, R, S, C>,
+    A: ActiveLineageSampler<H, G, D, R, S, C, E>,
 > {
     #[builder(default = 0.0_f64, setter(skip))]
     pub(super) time: f64,
     pub(super) speciation_probability_per_generation: f64,
     #[cfg_attr(feature = "cuda", r2cEmbed)]
     pub(super) habitat: H,
     #[cfg_attr(feature = "cuda", r2cEmbed)]
+    pub(super) rng: G,
+    #[cfg_attr(feature = "cuda", r2cEmbed)]
     pub(super) dispersal_sampler: D,
     pub(super) lineage_reference: PhantomData<R>,
     #[cfg_attr(feature = "cuda", r2cEmbed)]
@@ -46,20 +50,22 @@ pub struct Simulation<
 
 impl<
         H: Habitat,
-        D: DispersalSampler<H>,
+        G: RngCore,
+        D: DispersalSampler<H, G>,
         R: LineageReference<H>,
         S: LineageStore<H, R>,
-        C: CoalescenceSampler<H, R, S>,
-        E: EventSampler<H, D, R, S, C>,
-        A: ActiveLineageSampler<H, D, R, S, C, E>,
-    > Simulation<H, D, R, S, C, E, A>
+        C: CoalescenceSampler<H, G, R, S>,
+        E: EventSampler<H, G, D, R, S, C>,
+        A: ActiveLineageSampler<H, G, D, R, S, C, E>,
+    > Simulation<H, G, D, R, S, C, E, A>
 {
-    pub fn with_mut_split_active_lineage_sampler<
+    pub fn with_mut_split_active_lineage_sampler_and_rng<
         's,
         Q,
         F: FnOnce(
             &'s mut A,
-            &mut super::partial::active_lineager_sampler::PartialSimulation<'s, H, D, R, S, C, E>,
+            &mut super::partial::active_lineager_sampler::PartialSimulation<'s, H, G, D, R, S, C, E>,
+            &'s mut G,
         ) -> Q,
     >(
         &'s mut self,
@@ -68,14 +74,23 @@ impl<
         let mut simulation = super::partial::active_lineager_sampler::PartialSimulation {
             speciation_probability_per_generation: &self.speciation_probability_per_generation,
             habitat: &self.habitat,
+            rng: PhantomData::<G>,
             dispersal_sampler: &self.dispersal_sampler,
             lineage_reference: &self.lineage_reference,
             lineage_store: &mut self.lineage_store,
             coalescence_sampler: &self.coalescence_sampler,
             event_sampler: &self.event_sampler,
         };
 
-        func(&mut self.active_lineage_sampler, &mut simulation)
+        func(
+            &mut self.active_lineage_sampler,
+            &mut simulation,
+            &mut self.rng,
+        )
+    }
+
+    pub fn rng_mut(&mut self) -> &mut G {
+        &mut self.rng
     }
 
     pub fn active_lineage_sampler(&self) -> &A {