333 lines
12 KiB
Rust
333 lines
12 KiB
Rust
use std::collections::HashMap;
|
||
|
||
use serde::{Deserialize, Serialize};
|
||
|
||
use crate::expressions::expression::Expression;
|
||
use crate::map;
|
||
use crate::utils::array::Distinct;
|
||
|
||
type TruthMatrix = Vec<Vec<bool>>;
|
||
|
||
#[derive(Debug, Serialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct TruthTable {
|
||
header: Vec<String>,
|
||
truth_matrix: TruthMatrix,
|
||
}
|
||
|
||
#[derive(Debug, Default, Copy, Clone, Deserialize)]
|
||
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
|
||
pub enum Hide {
|
||
#[default]
|
||
None,
|
||
True,
|
||
False,
|
||
}
|
||
|
||
#[derive(Debug, Default, Copy, Clone, Deserialize)]
|
||
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
|
||
pub enum Sort {
|
||
#[default]
|
||
Default,
|
||
TrueFirst,
|
||
FalseFirst,
|
||
}
|
||
|
||
#[derive(Debug, Default, Deserialize)]
|
||
pub struct TruthTableOptions {
|
||
pub sort: Sort,
|
||
pub hide: Hide,
|
||
}
|
||
|
||
impl TruthTable {
|
||
// TODO options
|
||
pub fn new(expression: &Expression, options: TruthTableOptions) -> Self {
|
||
let header = Self::extract_header(expression);
|
||
let truth_matrix = Self::generate_truth_matrix(expression, &header);
|
||
Self { header, truth_matrix }
|
||
}
|
||
|
||
/// Extracts the header for the truth table from the expression
|
||
/// Duplicate values are removed.
|
||
/// - Arguments
|
||
/// - `expression` - The expression to extract the header from
|
||
/// - Returns
|
||
/// - A vector of strings representing the header
|
||
/// # Example
|
||
/// ```
|
||
/// let expression = TruthTable::extract_header(&atomic("A"));
|
||
/// let complex_expression = TruthTable::extract_header(&implies(and(atomic("A"), atomic("B")), or(atomic("C"), atomic("D"))));
|
||
/// assert_eq!(expression, vec!["A"]);
|
||
/// assert_eq!(complex_expression, vec!["A", "B", "A ⋀ B", "C", "D", "(C ⋁ D)", "A ⋀ B ➔ (C ⋁ D)"]);
|
||
/// ```
|
||
fn extract_header(expression: &Expression) -> Vec<String> {
|
||
match expression {
|
||
not @ Expression::Not(expr) => {
|
||
let mut header = Self::extract_header(expr);
|
||
header.push(not.to_string());
|
||
header.distinct();
|
||
header
|
||
}
|
||
binary @ Expression::Binary { left, right, .. } => {
|
||
let mut header = Self::extract_header(left);
|
||
header.extend(Self::extract_header(right));
|
||
header.push(binary.to_string());
|
||
header.distinct();
|
||
header
|
||
}
|
||
Expression::Atomic(value) => vec![value.clone()],
|
||
}
|
||
}
|
||
|
||
fn generate_truth_matrix(expression: &Expression, header: &[String]) -> TruthMatrix {
|
||
let mut atomics = expression.get_atomic_values()
|
||
.into_iter().collect::<Vec<String>>();
|
||
if atomics.is_empty() {
|
||
return vec![];
|
||
}
|
||
atomics.sort();
|
||
Self::truth_combinations(atomics.len()).iter()
|
||
.map(|combo| {
|
||
Self::resolve_expression(expression, &atomics.iter()
|
||
.enumerate()
|
||
.map(|(index, value)| (value.clone(), combo[index]))
|
||
.collect(), header)
|
||
}).collect()
|
||
}
|
||
|
||
fn truth_combinations(count: usize) -> TruthMatrix {
|
||
(0..2usize.pow(count as u32))
|
||
.map(|i| (0..count).rev()
|
||
// Just trust me bro
|
||
.map(|j| (i >> j) & 1 == 0).collect()
|
||
).collect()
|
||
}
|
||
|
||
fn resolve_expression(expression: &Expression, booleans: &HashMap<String, bool>, header: &[String]) -> Vec<bool> {
|
||
let expression_map = Self::_resolve_expression(expression, booleans);
|
||
let string_map = expression_map.iter()
|
||
.map(|(key, value)| (key.to_string(), *value))
|
||
.collect::<HashMap<String, bool>>();
|
||
|
||
header.iter()
|
||
.map(|s_expr| string_map.get(s_expr).copied().expect("Expression not found in map"))
|
||
.collect()
|
||
}
|
||
|
||
fn _resolve_expression<'a>(expression: &'a Expression, booleans: &HashMap<String, bool>) -> HashMap<&'a Expression, bool> {
|
||
match expression {
|
||
not @ Expression::Not(expr) => {
|
||
let mut map = Self::_resolve_expression(expr, booleans);
|
||
if let Some(value) = map.get(expr.as_ref()) {
|
||
map.insert(not, !value);
|
||
}
|
||
map
|
||
}
|
||
binary @ Expression::Binary { left, right, operator } => {
|
||
let left_map = Self::_resolve_expression(left, booleans);
|
||
let right_map = Self::_resolve_expression(right, booleans);
|
||
let mut map = left_map;
|
||
map.extend(right_map);
|
||
if let (Some(left_value), Some(right_value)) = (map.get(left.as_ref()), map.get(right.as_ref())) {
|
||
map.insert(binary, operator.eval(*left_value, *right_value));
|
||
}
|
||
map
|
||
}
|
||
atomic @ Expression::Atomic(value) => {
|
||
if let Some(value) = booleans.get(value) {
|
||
map!(atomic => *value)
|
||
} else {
|
||
unreachable!("Atomic value not found in booleans")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use crate::expressions::helpers::{and, atomic, implies, not, or};
|
||
use crate::matrix;
|
||
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn test_new_truth_table() {
|
||
let expression = and(atomic("A"), atomic("B"));
|
||
let truth_table = TruthTable::new(&expression, Default::default());
|
||
assert_eq!(truth_table.header, vec!["A", "B", "A ⋀ B"]);
|
||
assert_ne!(truth_table.truth_matrix, matrix![
|
||
true, true, true;
|
||
false, true, false;
|
||
true, false, false;
|
||
false, false, false
|
||
]);
|
||
assert_eq!(truth_table.truth_matrix, matrix![
|
||
true, true, true;
|
||
true, false, false;
|
||
false, true, false;
|
||
false, false, false
|
||
]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_new_truth_table_a_and_b_or_c() {
|
||
let expression = and(or(atomic("A"), atomic("C")), or(atomic("B"), atomic("C")));
|
||
let truth_table = TruthTable::new(&expression, Default::default());
|
||
let atomics = 3;
|
||
|
||
assert_eq!(truth_table.header, vec!["A", "C", "(A ⋁ C)", "B", "(B ⋁ C)", "(A ⋁ C) ⋀ (B ⋁ C)"]);
|
||
assert_eq!(truth_table.truth_matrix.len(), 2usize.pow(atomics as u32));
|
||
assert_eq!(truth_table.truth_matrix[0].len(), 6);
|
||
assert_eq!(truth_table.truth_matrix[0], vec![true, true, true, true, true, true]);
|
||
assert_eq!(truth_table.truth_matrix[1], vec![true, false, true, true, true, true]);
|
||
assert_eq!(truth_table.truth_matrix[2], vec![true, true, true, false, true, true]);
|
||
assert_eq!(truth_table.truth_matrix[3], vec![true, false, true, false, false, false]);
|
||
assert_eq!(truth_table.truth_matrix[4], vec![false, true, true, true, true, true]);
|
||
assert_eq!(truth_table.truth_matrix[5], vec![false, false, false, true, true, false]);
|
||
assert_eq!(truth_table.truth_matrix[6], vec![false, true, true, false, true, true]);
|
||
assert_eq!(truth_table.truth_matrix[7], vec![false, false, false, false, false, false]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_truth_combinations_2() {
|
||
let combinations = TruthTable::truth_combinations(2);
|
||
assert_eq!(combinations, matrix![
|
||
true, true;
|
||
true, false;
|
||
false, true;
|
||
false, false
|
||
]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_truth_combinations_3() {
|
||
let combinations = TruthTable::truth_combinations(3);
|
||
assert_eq!(combinations, matrix![
|
||
true, true, true;
|
||
true, true, false;
|
||
true, false, true;
|
||
true, false, false;
|
||
false, true, true;
|
||
false, true, false;
|
||
false, false, true;
|
||
false, false, false
|
||
]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_resolve_expression_and_all_true() {
|
||
let expression = and(atomic("A"), atomic("B"));
|
||
let booleans = map!["A".into() => true, "B".into() => true];
|
||
let header = vec!["A".into(), "B".into(), "A ⋀ B".into()];
|
||
let values = TruthTable::resolve_expression(&expression, &booleans, &header);
|
||
assert_eq!(values, vec![true, true, true]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_resolve_expression_and_1_true_1_false() {
|
||
let expression = and(atomic("A"), atomic("B"));
|
||
let booleans = map!["A".into() => true, "B".into() => false];
|
||
let header = vec!["A".into(), "B".into(), "A ⋀ B".into()];
|
||
let values = TruthTable::resolve_expression(&expression, &booleans, &header);
|
||
assert_eq!(values, vec![true, false, false]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_resolve_expression_or_1_true_1_false() {
|
||
let expression = or(atomic("A"), atomic("B"));
|
||
let booleans = map!["A".into() => true, "B".into() => false];
|
||
let header = vec!["A".into(), "B".into(), "(A ⋁ B)".into()];
|
||
let values = TruthTable::resolve_expression(&expression, &booleans, &header);
|
||
assert_eq!(values, vec![true, false, true]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_resolve_expression_duplicate_atomic() {
|
||
let expression = and(atomic("A"), atomic("A"));
|
||
let booleans = map!["A".into() => true];
|
||
let header = vec!["A".into(), "A ⋀ A".into()];
|
||
let values = TruthTable::resolve_expression(&expression, &booleans, &header);
|
||
assert_eq!(values, vec![true, true]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_resolve_expression_even_more_duplicates() {
|
||
let expression = and(atomic("A"), and(atomic("A"), and(atomic("A"), atomic("A"))));
|
||
let booleans = HashMap::from([("A".into(), true)]);
|
||
let header = vec!["A".into(), "A ⋀ A".into(), "A ⋀ A ⋀ A".into(), "A ⋀ A ⋀ A ⋀ A".into()];
|
||
let values = TruthTable::resolve_expression(&expression, &booleans, &header);
|
||
assert_eq!(values, vec![true, true, true, true]);
|
||
}
|
||
|
||
#[test]
|
||
fn _test_resolve_expression_even_more_duplicates() {
|
||
let expression = and(atomic("A"), and(atomic("A"), and(atomic("A"), atomic("A"))));
|
||
let booleans = HashMap::from([("A".into(), true)]);
|
||
let values = TruthTable::_resolve_expression(&expression, &booleans);
|
||
assert_eq!(values, HashMap::from([
|
||
(&atomic("A"), true),
|
||
(&and(atomic("A"), atomic("A")), true),
|
||
(&and(atomic("A"), and(atomic("A"), atomic("A"))), true),
|
||
(&and(atomic("A"), and(atomic("A"), and(atomic("A"), atomic("A")))), true),
|
||
]));
|
||
}
|
||
|
||
|
||
#[test]
|
||
fn test_atomic_expression() {
|
||
let expression = atomic("A");
|
||
let header = TruthTable::extract_header(&expression);
|
||
assert_eq!(header, vec!["A"]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_not_expression() {
|
||
let expression = not(atomic("A"));
|
||
let header = TruthTable::extract_header(&expression);
|
||
assert_eq!(header, vec!["A", "¬A"]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_binary_and_expression() {
|
||
let expression = and(atomic("A"), atomic("B"));
|
||
let header = TruthTable::extract_header(&expression);
|
||
assert_eq!(header, vec!["A", "B", "A ⋀ B"]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_binary_or_expression() {
|
||
let expression = or(atomic("A"), atomic("B"));
|
||
let header = TruthTable::extract_header(&expression);
|
||
assert_eq!(header, vec!["A", "B", "(A ⋁ B)"]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_binary_implies_expression() {
|
||
let expression = implies(atomic("A"), atomic("B"));
|
||
let header = TruthTable::extract_header(&expression);
|
||
assert_eq!(header, vec!["A", "B", "A ➔ B"]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_complex_expression() {
|
||
let expression = implies(and(atomic("A"), atomic("B")), or(atomic("C"), atomic("D")));
|
||
let header = TruthTable::extract_header(&expression);
|
||
assert_eq!(header, vec!["A", "B", "A ⋀ B", "C", "D", "(C ⋁ D)", "A ⋀ B ➔ (C ⋁ D)"]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_equal_expressions_should_not_duplicate() {
|
||
let expression = and(atomic("A"), and(atomic("A"), and(atomic("A"), atomic("A"))));
|
||
let header = TruthTable::extract_header(&expression);
|
||
assert_eq!(header, vec!["A", "A ⋀ A", "A ⋀ A ⋀ A", "A ⋀ A ⋀ A ⋀ A"]);
|
||
}
|
||
|
||
#[test]
|
||
fn test_somewhat_equal() {
|
||
let expression = and(atomic("A"), and(or(not(atomic("A")), atomic("B")), atomic("A")));
|
||
let header = TruthTable::extract_header(&expression);
|
||
assert_eq!(header, vec!["A", "¬A", "B", "(¬A ⋁ B)", "(¬A ⋁ B) ⋀ A", "A ⋀ (¬A ⋁ B) ⋀ A"]);
|
||
}
|
||
}
|