rmatrix_ks 0.5.0

matrix and some algebra in Rust
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
131
132
133
134
135
136
137
138
139
140

//! # matrix::serde
//!
//! Serialize and deserialize the matrix,
//! including obtaining the matrix from standard input.

use crate::matrix::matrix::Matrix;

use std::{
    fs::File,
    io::{BufReader, BufWriter},
    path::Path,
};

/// Write the matrix to a file.
///
/// # Examples
///
/// ```rust
/// use rmatrix_ks::{
///     matrix::{matrix::Matrix, serde::to_file},
///     number::instances::{complex::Complex, float::Float},
/// };
///
/// fn main() {
///     let path = "data/test.txt";
///     let m = Matrix::<Complex<Float>, 16, 16>::rand(
///         Complex::of(Float::of(-2.0), Float::of(-2.0)),
///         Complex::of(Float::of(2.0), Float::of(2.0)),
///     );
///     to_file(&m, path);
/// }
/// ```
pub fn to_file<N, P, const R: usize, const C: usize>(m: &Matrix<N, R, C>, path: P)
where
    N: std::fmt::Debug,
    P: AsRef<Path> + std::fmt::Debug,
{
    use std::io::Write;

    let file = File::create(&path).expect(&format!(
        "Error[matrix::serde::to_file]: Failed to create file ({:?}).",
        path
    ));
    let mut writer = BufWriter::new(file);
    let data = m
        .linear_iter()
        .map(|e| format!("{:?}", e))
        .collect::<Vec<_>>()
        .join(",");
    writer
        .write_all(data.as_bytes())
        .expect("Error[matrix::serde::to_file]: Failed to write the matrix to the file.");
}

/// Read the matrix from a file.
///
/// # Examples
///
/// ```rust
/// use rmatrix_ks::{
///     matrix::{matrix::Matrix, serde::from_file},
///     number::instances::{complex::Complex, float::Float},
/// };
///
/// fn main() {
///     let path = "data/test.txt";
///     let m: Option<Matrix<Complex<Float>, 16, 16>> = from_file(path);
///     assert!(m.is_some());
/// }
/// ```
pub fn from_file<N, P, const R: usize, const C: usize>(path: P) -> Option<Matrix<N, R, C>>
where
    N: Clone + std::str::FromStr,
    P: AsRef<Path> + std::fmt::Debug,
{
    use std::io::Read;

    let file = File::open(&path).expect(&format!(
        "Error[matrix::serde::from_file]: Failed to create file ({:?}).",
        path
    ));
    let mut reader = BufReader::new(file);
    let mut data = String::new();
    reader.read_to_string(&mut data).expect(
        "Error[matrix::serde::from_file]: Failed to read the file content into the string.",
    );
    let inner = data
        .split(",")
        .map(|s| s.trim())
        .filter(|s| !s.is_empty())
        .map(|s| {
            s.parse::<N>().ok().expect(&format!(
                "Error[matrix::serde::from_file]: Failed to parse ({}) from the string.",
                s
            ))
        })
        .collect::<Vec<N>>();
    Matrix::of(&inner)
}

/// Read the matrix from user input.
///
/// # Examples
///
/// ```rust,no_run
/// use rmatrix_ks::{matrix::serde::from_stdin, number::instances::word8::Word8};
///
/// fn main() {
///     let m = from_stdin::<Word8, 3, 3>();
///     assert_eq!(m.shape(), (3, 3));
/// }
/// ```
pub fn from_stdin<N, const R: usize, const C: usize>() -> Matrix<N, R, C>
where
    N: std::str::FromStr,
{
    let stdin = std::io::stdin();
    let mut buffer = String::new();
    let mut inner = Vec::with_capacity(R * C);
    println!("Please enter the matrix elements ({}, {}):", R, C);
    while inner.len() < R * C {
        stdin
            .read_line(&mut buffer)
            .expect("Error[matrix::serde::from_stdin]: Failed to read data from 'stdin'.");
        buffer
            .trim()
            .split(|c: char| c.is_whitespace() || c == ',')
            .filter(|s| !s.is_empty())
            .for_each(|s| {
                let e = s.parse::<N>().ok().expect(&format!(
                    "Error[matrix::serde::from_file]: Failed to parse ({}) from the string.",
                    s
                ));
                inner.push(e);
            });
        // Prevent duplicate reads.
        buffer.clear();
    }
    Matrix { inner }
}