truth-table 0.2.0

Generate a truth table from a formula
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

use std::io::Write;

use ansi_term::Colour::{Green, Red};

use crate::{args, eval, lexer};

pub fn write_as_table(
    w: &mut impl Write,
    args: args::Args,
    color: bool,
) -> Result<(), Box<dyn std::error::Error>> {
    //let args = args::Args::new()?;
    let tokens = lexer::Tokens::from_text(&args.text);
    let equation = eval::Equation::from_tokens(&tokens);
    let combinations = equation.eval_all();
    // Write the first header row
    for ident in &equation.idents {
        write!(w, "{} ", ident)?;
    }
    // Display the requested equation
    write!(w, "| {}", tokens)?;
    writeln!(w)?;
    // Display all possible combinations
    for (values, result) in combinations {
        for (_, boolean) in values {
            if color {
                write!(
                    w,
                    "{} ",
                    if boolean {
                        Green.paint("1")
                    } else {
                        Red.paint("0")
                    }
                )?;
            } else {
                write!(w, "{} ", if boolean { "1" } else { "0" })?;
            }
        }
        if color {
            writeln!(
                w,
                "| {}",
                if result {
                    Green.paint("1")
                } else {
                    Red.paint("0")
                }
            )?;
        } else {
            writeln!(w, "| {}", if result { "1" } else { "0" })?;
        }
    }
    Ok(())
}

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

    #[test]
    fn format() {
        let table = "\
a b | a ∧ ¬b
0 0 | 0
0 1 | 0
1 0 | 1
1 1 | 0
";
        let mut buf = Vec::new();
        write_as_table(
            &mut buf,
            args::Args {
                text: "a and not b".to_owned(),
            },
            false,
        )
        .unwrap();
        assert_eq!(std::str::from_utf8(&buf).unwrap(), table);
    }

    #[test]
    fn format2() {
        let table = "\
x y | ¬x ∨ y
0 0 | 1
0 1 | 1
1 0 | 0
1 1 | 1
";
        let mut buf = Vec::new();
        write_as_table(
            &mut buf,
            args::Args {
                text: "not x or y".to_owned(),
            },
            false,
        )
        .unwrap();
        assert_eq!(std::str::from_utf8(&buf).unwrap(), table);
    }
}