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

use crate::*;
use std::convert::TryInto;
// MatrixDxD
// --------------------------------------------------
impl<T: Copy> From<(usize, usize, T)> for MatrixDxD<T> {
    fn from((rows, columns, x): (usize, usize, T)) -> Self {
        Self {
            data: vec![x; rows * columns],
            rows,
            columns,
        }
    }
}
// MatrixSxS
// --------------------------------------------------
impl<T: Clone + std::fmt::Debug, const ROWS: usize, const COLUMNS: usize> From<[[T; COLUMNS]; ROWS]>
    for MatrixSxS<T, ROWS, COLUMNS>
where
    [(); ROWS * COLUMNS]:,
{
    fn from(data: [[T; COLUMNS]; ROWS]) -> Self {
        Self {
            data: data
                .iter()
                .cloned()
                .flatten()
                .collect::<Vec<_>>()
                .try_into()
                .unwrap(),
        }
    }
}
impl<T: Copy, const ROWS: usize, const COLUMNS: usize> From<T> for MatrixSxS<T, ROWS, COLUMNS>
where
    [(); ROWS * COLUMNS]:,
{
    fn from(x: T) -> Self {
        Self {
            data: [x; ROWS * COLUMNS],
        }
    }
}
impl<T, const ROWS: usize, const COLUMNS: usize> From<[T; ROWS * COLUMNS]>
    for MatrixSxS<T, ROWS, COLUMNS>
where
    [(); ROWS * COLUMNS]:,
{
    fn from(data: [T; ROWS * COLUMNS]) -> Self {
        Self { data }
    }
}
impl<T: Clone, const ROWS: usize, const COLUMNS: usize> From<&[T; ROWS * COLUMNS]>
    for MatrixSxS<T, ROWS, COLUMNS>
{
    fn from(data: &[T; ROWS * COLUMNS]) -> Self {
        Self { data: data.clone() }
    }
}
// MatrixDxS
// --------------------------------------------------
impl<T, const COLUMNS: usize> From<Vec<[T; COLUMNS]>> for MatrixDxS<T, COLUMNS> {
    fn from(data: Vec<[T; COLUMNS]>) -> Self {
        let len = data.len();
        Self {
            data: data.into_iter().flatten().collect::<Vec<_>>(),
            rows: len,
        }
    }
}
impl<T: Copy, const COLUMNS: usize> From<(usize, T)> for MatrixDxS<T, COLUMNS> {
    fn from((rows, x): (usize, T)) -> Self {
        Self {
            data: vec![x; rows * COLUMNS],
            rows,
        }
    }
}
// MatrixSxD
// --------------------------------------------------
impl<T: Copy, const ROWS: usize> From<(usize, T)> for MatrixSxD<T, ROWS> {
    fn from((columns, x): (usize, T)) -> Self {
        Self {
            data: vec![x; ROWS * columns],
            columns,
        }
    }
}