pictorus-blocks 0.0.0

Implementations of Pictorus blocks.
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use nalgebra::{ArrayStorage, Const, DimMin, SquareMatrix, ToTypenum};
use pictorus_block_data::{BlockData as OldBlockData, FromPass};
use pictorus_traits::{Matrix, Pass, PassBy, ProcessBlock, Scalar};

pub struct Parameters {}

impl Default for Parameters {
    fn default() -> Self {
        Self::new()
    }
}

impl Parameters {
    pub fn new() -> Self {
        Self {}
    }
}

/// A block that calculates the determinant of a square matrix.
pub struct DeterminantBlock<S: Scalar, T> {
    pub data: OldBlockData,
    buffer: S,
    phantom_type: core::marker::PhantomData<T>,
}

impl<S, T> Default for DeterminantBlock<S, T>
where
    S: Default + Scalar + Pass,
    T: Pass,
    OldBlockData: FromPass<S>,
{
    fn default() -> Self {
        Self {
            data: <OldBlockData as FromPass<S>>::from_pass(S::default().as_by()),
            buffer: S::default(),
            phantom_type: core::marker::PhantomData,
        }
    }
}

macro_rules! impl_determinant_block {
    ($type:ty) => {
        impl<const N: usize> ProcessBlock for DeterminantBlock<$type, Matrix<N, N, $type>>
        where
            Const<N>: ToTypenum + DimMin<Const<N>, Output = Const<N>>,
            OldBlockData: FromPass<$type>,
        {
            type Inputs = Matrix<N, N, $type>;
            type Output = $type;
            type Parameters = Parameters;

            fn process<'b>(
                &'b mut self,
                _parameters: &Self::Parameters,
                _context: &dyn pictorus_traits::Context,
                inputs: PassBy<'_, Self::Inputs>,
            ) -> PassBy<'b, Self::Output> {
                self.buffer =
                    SquareMatrix::from_array_storage(ArrayStorage(inputs.data)).determinant();
                self.data = OldBlockData::from_scalar(self.buffer.into());
                self.buffer
            }
        }

        impl ProcessBlock for DeterminantBlock<$type, $type>
        where
            OldBlockData: FromPass<$type>,
        {
            type Inputs = $type;
            type Output = $type;
            type Parameters = Parameters;

            fn process<'b>(
                &'b mut self,
                _parameters: &Self::Parameters,
                _context: &dyn pictorus_traits::Context,
                inputs: PassBy<'_, Self::Inputs>,
            ) -> PassBy<'b, Self::Output> {
                self.buffer = inputs;
                self.data = OldBlockData::from_scalar(self.buffer.into());
                self.buffer
            }
        }
    };
}

impl_determinant_block!(f32);
impl_determinant_block!(f64);

#[cfg(test)]
mod tests {
    use super::*;
    use crate::testing::StubContext;
    use paste::paste;
    use pictorus_block_data::BlockDataType;

    macro_rules! impl_determinant_tests {
        ($type:ty) => {
            paste! {
                #[test]
                fn [<test_vector_determinant_ $type>]() {
                    let mut det_block = DeterminantBlock::<$type, Matrix<2, 2, $type>>::default();

                    let c = StubContext::default();
                    let p = Parameters::new();
                    let input = Matrix {
                        data: [[1.0, 2.0], [3.0, 4.0]]
                    };
                    let output = det_block.process(&p, &c, &input);

                    assert!(output == -2.0);
                    assert!(det_block.data.scalar() == -2.0);
                    assert!(det_block.data.get_type() == BlockDataType::Scalar);

                    let mut det_block_3x3 = DeterminantBlock::<$type, Matrix<3, 3, $type>>::default();
                    let input_3x3 = Matrix {
                        data: [[2.0, 0.0, 1.0], [3.0, 4.0, 6.0], [1.0, 5.0, 2.0]]
                    };
                    let output = det_block_3x3.process(&p, &c, &input_3x3);
                    assert!(output == -33.0);
                    assert!(det_block_3x3.data.scalar() == -33.0);
                    assert!(det_block_3x3.data.get_type() == BlockDataType::Scalar);
                }
            }
        }
    }

    impl_determinant_tests!(f32);
    impl_determinant_tests!(f64);
}