chemrust-formats 0.2.0

The core modules defining the flow and structs of data in computational chemistry routines.
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

use std::fmt::Display;

use nalgebra::Matrix4;

use crate::Cell;

#[derive(Debug, Clone)]
pub struct SymmetryOps {
    operations: Vec<Matrix4<f64>>,
}

impl SymmetryOps {
    pub fn write_in_cell(&self) -> String {
        Cell::write_block(("SYMMETRY_OPS".into(), format!("{}", self)))
    }
}

impl Default for SymmetryOps {
    fn default() -> Self {
        Self {
            operations: vec![Matrix4::identity()],
        }
    }
}

impl Display for SymmetryOps {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let ops_output = self
            .operations
            .iter()
            .map(|mat| {
                let rot_part = mat.fixed_view::<3, 3>(0, 0);
                let translate_part = mat.fixed_view::<3, 1>(0, 3);
                let rot_part_output = rot_part
                    .column_iter() // Should be column-major order in .cell? Not sure.
                    .map(|col| {
                        col.iter()
                            .map(|value| format!("{:23.15}", value))
                            .collect::<Vec<String>>()
                            .concat()
                    })
                    .collect::<Vec<String>>()
                    .join("\n");
                let translate_output = translate_part
                    .iter()
                    .map(|value| format!("{:23.15}", value))
                    .collect::<Vec<String>>()
                    .concat();
                let output = vec![rot_part_output, "\n".into(), translate_output, "\n".into()];
                output.concat()
            })
            .collect::<Vec<String>>()
            .concat();
        write!(f, "{ops_output}")
    }
}

#[cfg(test)]
mod test {
    use super::SymmetryOps;

    #[test]
    fn test_sym_out() {
        let sym_ops = SymmetryOps::default();
        println!("{}", sym_ops.write_in_cell());
    }
}