diffusionx 0.12.0

A multi-threaded crate for random number generation and stochastic process simulation, with optional GPU acceleration.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

#![cfg_attr(docsrs, feature(doc_cfg))]
#![doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/README.md"))]

#[cfg(feature = "mimalloc")]
#[global_allocator]
static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;

/// Numeric bound used by simulations whose time and state values are floating point.
///
/// This trait is implemented automatically for any type that satisfies the required
/// arithmetic, constant, formatting, and thread-safety bounds. Most continuous
/// process APIs use `T: FloatExt` so they can work with `f32`, `f64`, or compatible
/// numeric types without repeating the full bound list.
pub trait FloatExt:
    num_traits::Float
    + num_traits::FloatConst
    + std::fmt::Debug
    + Send
    + Sync
    + std::ops::AddAssign<Self>
    + std::ops::MulAssign<Self>
    + std::iter::Sum
{
}

impl<T> FloatExt for T where
    T: num_traits::Float
        + num_traits::FloatConst
        + std::fmt::Debug
        + Send
        + Sync
        + std::ops::AddAssign<Self>
        + std::ops::MulAssign<Self>
        + std::iter::Sum
{
}

/// Numeric bound used by discrete processes for step counters and integer states.
///
/// This trait is implemented automatically for primitive integer-like types that
/// are copyable, summable, debuggable, and safe to share across worker threads.
pub trait IntExt: num_traits::PrimInt + std::fmt::Debug + Send + Sync + std::iter::Sum {}
impl<T> IntExt for T where T: num_traits::PrimInt + std::fmt::Debug + Send + Sync + std::iter::Sum {}

/// Numeric bound used by process state values that may be integer or floating point.
///
/// `RealExt` is intentionally less restrictive than [`FloatExt`]: it supports
/// arithmetic, conversion to and from numeric types, ordering, copying, and
/// summation, but does not require floating-point-only operations such as
/// exponentials or square roots.
pub trait RealExt:
    num_traits::Num
    + num_traits::NumCast
    + std::fmt::Debug
    + Send
    + Sync
    + Copy
    + PartialOrd
    + std::iter::Sum
{
}

impl<T> RealExt for T where
    T: num_traits::Num
        + num_traits::NumCast
        + std::fmt::Debug
        + Send
        + Sync
        + Copy
        + PartialOrd
        + std::iter::Sum
{
}

mod error;
pub use error::*;

/// Random number generation module
pub mod random;

/// Stochastic process simulation module
pub mod simulation;

/// Utility functions and algorithms
pub mod utils;

/// Visualization module
#[cfg(feature = "visualize")]
#[cfg_attr(docsrs, doc(cfg(feature = "visualize")))]
pub mod visualize;

/// GPU acceleration module
#[cfg(any(feature = "cuda", feature = "metal"))]
pub mod gpu;