prodef 0.1.0

A simple Rust crate for handling probability distributions.
Documentation 
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

//! Types and traits for representing function domains.

mod domm;
mod doms;

pub use domm::*;
pub use doms::*;

use nalgebra::{
    DefaultAllocator, Dim, OVector, RealField, Scalar, U1, VectorView, allocator::Allocator,
};
use serde::{Deserialize, Serialize};
use std::fmt::Debug;

/// A trait that is shared by all types that represent a function domain.
pub trait Domain<T, D>: Clone + Debug + PartialEq + Send + Sync
where
    T: Scalar,
    D: Dim,
    DefaultAllocator: Allocator<D>,
{
    /// Clip `sample`` to be contained within the domain.
    ///
    /// This function returns the input value if the given
    /// sample is already contained within the domain.
    fn clip<RStride: Dim, CStride: Dim>(
        &self,
        sample: &VectorView<T, D, RStride, CStride>,
    ) -> OVector<T, D>;

    /// Returns `true` if the sample is contained within the domain.
    fn contains<RStride: Dim, CStride: Dim>(
        &self,
        sample: &VectorView<T, D, RStride, CStride>,
    ) -> bool;

    /// Returns the maximum value of the domain along each dimension.
    fn maximum_values(&self) -> Option<OVector<T, D>>;

    /// Returns the minimum value of the domain along each dimension.
    fn minimum_values(&self) -> Option<OVector<T, D>>;

    /// Returns the maximum size of the domain along each dimension.
    fn size(&self) -> OVector<Option<T>, D>
    where
        T: RealField;
}

/// An unbounded domain.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct UDomain<D>(D);

impl<D> UDomain<D> {
    /// Create a new unbounded domain.
    pub fn new(dim: D) -> Self {
        UDomain(dim)
    }
}

impl<T, D> Domain<T, D> for UDomain<D>
where
    T: PartialOrd + Scalar,
    D: Dim,
    DefaultAllocator: Allocator<D>,
{
    fn clip<RStride: Dim, CStride: Dim>(
        &self,
        sample: &VectorView<T, D, RStride, CStride>,
    ) -> OVector<T, D> {
        sample.clone_owned()
    }

    fn contains<RStride: Dim, CStride: Dim>(
        &self,
        _sample: &VectorView<T, D, RStride, CStride>,
    ) -> bool {
        true
    }

    fn maximum_values(&self) -> Option<OVector<T, D>> {
        None
    }

    fn minimum_values(&self) -> Option<OVector<T, D>> {
        None
    }

    fn size(&self) -> OVector<Option<T>, D> {
        OVector::<Option<T>, D>::from_element_generic(self.0, U1, None)
    }
}