diff --git a/src/adder.rs b/src/adder.rs index 2dfc4c6..09eadf3 100644 --- a/src/adder.rs +++ b/src/adder.rs @@ -12,4 +12,3 @@ pub fn adder(a: u32, b: u32) -> u32 { } result } - diff --git a/src/ast.rs b/src/ast.rs index 711ad0e..bad9321 100644 --- a/src/ast.rs +++ b/src/ast.rs @@ -1,6 +1,5 @@ mod tests; - #[derive(Debug, Clone, Copy, PartialEq)] pub enum Token { Negation, @@ -8,15 +7,18 @@ pub enum Token { Disjunction, ExclusiveDisjunction, MaterialCondition, - LogicalEquivalence + LogicalEquivalence, } #[derive(Debug, Clone, PartialEq)] -pub enum Node { +pub enum Node +where + T: Clone + std::fmt::Debug, +{ Leaf(T), Unary { operator: Token, - operand: Box> + operand: Box>, }, Binary { operator: Token, @@ -26,27 +28,207 @@ pub enum Node { } impl Node -where T: Clone { +where + T: Clone + std::fmt::Debug, +{ + fn negation_conjunction_to_nnf(lhs: &Box>, rhs: &Box>) -> Node { + Node::Binary { + operator: Token::Disjunction, + lhs: Box::new(Node::Unary { + operator: Token::Negation, + operand: Box::new(*lhs.clone()), + }), + rhs: Box::new(Node::Unary { + operator: Token::Negation, + operand: Box::new(*rhs.clone()), + }), + } + } + + fn negation_disjunction_to_nnf(lhs: &Box>, rhs: &Box>) -> Node { + Node::Binary { + operator: Token::Conjunction, + lhs: Box::new(Node::Unary { + operator: Token::Negation, + operand: Box::new(*lhs.clone()), + }), + rhs: Box::new(Node::Unary { + operator: Token::Negation, + operand: Box::new(*rhs.clone()), + }), + } + } + + fn negation_material_condition_to_nnf(lhs: &Box>, rhs: &Box>) -> Node { + Node::Binary { + operator: Token::Conjunction, + lhs: Box::new(*lhs.clone()), + rhs: Box::new(Node::Unary { + operator: Token::Negation, + operand: Box::new(*rhs.clone()), + }), + } + } + + fn material_condition_to_nnf(lhs: &Box>, rhs: &Box>) -> Node { + Node::Binary { + operator: Token::Disjunction, + lhs: Box::new(Node::Unary { + operator: Token::Negation, + operand: Box::new(*lhs.clone()), + }), + rhs: Box::new(*rhs.clone()), + } + } + + fn negation_exclusive_disjunction_to_nnf(lhs: &Box>, rhs: &Box>) -> Node { + Node::Binary { + operator: Token::Disjunction, + lhs: Box::new(Node::Binary { + operator: Token::Conjunction, + lhs: Box::new(Node::Unary { + operator: Token::Negation, + operand: Box::new(*lhs.clone()), + }), + rhs: Box::new(Node::Unary { + operator: Token::Negation, + operand: Box::new(*rhs.clone()), + }), + }), + rhs: Box::new(Node::Binary { + operator: Token::Conjunction, + lhs: Box::new(*lhs.clone()), + rhs: Box::new(*rhs.clone()), + }), + } + } + + fn exclusive_disjunction_to_nnf(lhs: &Box>, rhs: &Box>) -> Node { + Node::Binary { + operator: Token::Conjunction, + lhs: Box::new(Node::Binary { + operator: Token::Disjunction, + lhs: Box::new(*lhs.clone()), + rhs: Box::new(*rhs.clone()), + }), + rhs: Box::new(Node::Binary { + operator: Token::Disjunction, + lhs: Box::new(Node::Unary { + operator: Token::Negation, + operand: Box::new(*lhs.clone()), + }), + rhs: Box::new(Node::Unary { + operator: Token::Negation, + operand: Box::new(*rhs.clone()), + }), + }), + } + } + + fn logical_equivalence_to_nnf(lhs: &Box>, rhs: &Box>) -> Node { + Node::Binary { + operator: Token::Conjunction, + lhs: Box::new(Node::Binary { + operator: Token::Disjunction, + lhs: Box::new(Node::Unary { + operator: Token::Negation, + operand: Box::new(*lhs.clone()), + }), + rhs: Box::new(*rhs.clone()), + }), + rhs: Box::new(Node::Binary { + operator: Token::Disjunction, + lhs: Box::new(Node::Unary { + operator: Token::Negation, + operand: Box::new(*rhs.clone()), + }), + rhs: Box::new(*lhs.clone()), + }), + } + } + + fn negation_logical_equivalence_to_nnf(lhs: &Box>, rhs: &Box>) -> Node { + Node::Binary { + operator: Token::Disjunction, + lhs: Box::new(Node::Binary { + operator: Token::Conjunction, + lhs: Box::new(*lhs.clone()), + rhs: Box::new(Node::Unary { + operator: Token::Negation, + operand: Box::new(*rhs.clone()), + }), + }), + rhs: Box::new(Node::Binary { + operator: Token::Conjunction, + lhs: Box::new(*rhs.clone()), + rhs: Box::new(Node::Unary { + operator: Token::Negation, + operand: Box::new(*lhs.clone()), + }), + }), + } + } + pub fn simplify(&mut self) { match self { - Node::Unary { operator, operand } if *operator == Token::Negation => { - if let Node::Unary { operator: inner_op, operand: inner_operand } = &**operand { - if *inner_op == Token::Negation { - *self = *inner_operand.clone(); // Replace unary node with its operand - self.simplify(); // Continue simplification recursively + Node::Unary { operator, operand } if *operator == Token::Negation => match &**operand { + Node::Unary { + operator: inner_op, + operand: inner_operand, + } if *inner_op == Token::Negation => { + *self = *inner_operand.clone(); + self.simplify(); + } + Node::Binary { + operator: inner_op, + lhs: inner_lhs, + rhs: inner_rhs, + } => { + *self = match *inner_op { + Token::Conjunction => { + Self::negation_conjunction_to_nnf(inner_lhs, inner_rhs) + } + Token::Disjunction => { + Self::negation_disjunction_to_nnf(inner_lhs, inner_rhs) + } + Token::ExclusiveDisjunction => { + Self::negation_exclusive_disjunction_to_nnf(inner_lhs, inner_rhs) + } + Token::LogicalEquivalence => { + Self::negation_logical_equivalence_to_nnf(inner_lhs, inner_rhs) + } + Token::MaterialCondition => { + Self::negation_material_condition_to_nnf(inner_lhs, inner_rhs) + } + _ => unreachable!(), + }; + self.simplify(); + } + _ => (), + }, + Node::Binary { + operator, lhs, rhs, .. + } => { + if let Some(node) = match *operator { + Token::ExclusiveDisjunction => { + Some(Self::exclusive_disjunction_to_nnf(lhs, rhs)) } + Token::LogicalEquivalence => Some(Self::logical_equivalence_to_nnf(lhs, rhs)), + Token::MaterialCondition => Some(Self::material_condition_to_nnf(lhs, rhs)), + _ => None, + } { + *self = node.clone(); + self.simplify(); + } else { + lhs.simplify(); + rhs.simplify(); } } - Node::Binary { lhs, rhs, .. } => { - lhs.simplify(); - rhs.simplify(); - } - _ => {} + _ => (), } } } - impl Node { pub fn parse_formula(formula: &str) -> Node { let mut stack = vec![]; @@ -60,7 +242,7 @@ impl Node { '^' => add_binary_node(&mut stack, Token::ExclusiveDisjunction), '>' => add_binary_node(&mut stack, Token::MaterialCondition), '=' => add_binary_node(&mut stack, Token::LogicalEquivalence), - _ => panic!("Error: {} is not a valid character", c) + _ => panic!("Error: {} is not a valid character", c), } } stack.pop().unwrap() @@ -72,17 +254,17 @@ impl Node { Node::Unary { operator, operand } => { str.push_str(Self::ast_to_formula(operand).as_str()); str.push(token_to_char(*operator)); - }, + } Node::Binary { operator, lhs, rhs } => { str.push_str(Self::ast_to_formula(lhs).as_str()); str.push_str(Self::ast_to_formula(rhs).as_str()); str.push(token_to_char(*operator)); - }, + } Node::Leaf(b) => str.push(bool_to_char(*b)), }; str } -} +} impl Node { pub fn parse_formula(formula: &str) -> Node { @@ -96,7 +278,7 @@ impl Node { '^' => add_binary_node(&mut stack, Token::ExclusiveDisjunction), '>' => add_binary_node(&mut stack, Token::MaterialCondition), '=' => add_binary_node(&mut stack, Token::LogicalEquivalence), - _ => panic!("Error: {} is not a valid character", c) + _ => panic!("Error: {} is not a valid character", c), } } stack.pop().unwrap() @@ -108,19 +290,22 @@ impl Node { Node::Unary { operator, operand } => { str.push_str(Self::ast_to_formula(operand).as_str()); str.push(token_to_char(*operator)); - }, + } Node::Binary { operator, lhs, rhs } => { str.push_str(Self::ast_to_formula(lhs).as_str()); str.push_str(Self::ast_to_formula(rhs).as_str()); str.push(token_to_char(*operator)); - }, + } Node::Leaf(c) => str.push(*c), }; str } } -pub fn add_unary_node(stack: &mut Vec>, token: Token) { +pub fn add_unary_node(stack: &mut Vec>, token: Token) +where + T: Clone + std::fmt::Debug, +{ let operand = Box::new(stack.pop().unwrap()); stack.push(Node::Unary { operator: token, @@ -128,31 +313,33 @@ pub fn add_unary_node(stack: &mut Vec>, token: Token) { }); } -pub fn add_binary_node(stack: &mut Vec>, token: Token) { +pub fn add_binary_node(stack: &mut Vec>, token: Token) +where + T: Clone + std::fmt::Debug, +{ let rhs = Box::new(stack.pop().unwrap()); let lhs = Box::new(stack.pop().unwrap()); stack.push(Node::Binary { operator: token, lhs, - rhs + rhs, }); } fn bool_to_char(b: bool) -> char { match b { false => '0', - true => '1' + true => '1', } } fn token_to_char(token: Token) -> char { match token { Token::Negation => '!', - Token::Conjunction =>'&', + Token::Conjunction => '&', Token::Disjunction => '|', Token::ExclusiveDisjunction => '^', Token::MaterialCondition => '>', Token::LogicalEquivalence => '=', } } - diff --git a/src/ast/tests.rs b/src/ast/tests.rs index 28f9c73..23df1a9 100644 --- a/src/ast/tests.rs +++ b/src/ast/tests.rs @@ -1,6 +1,6 @@ #[cfg(test)] mod tests { - use crate::ast::{ add_binary_node, Node, Token }; + use crate::ast::{add_binary_node, Node, Token}; #[test] fn add_nodes() { @@ -8,7 +8,7 @@ mod tests { let rhs = vec![Node::Binary { operator: Token::Conjunction, lhs: Box::new(Node::Leaf(true)), - rhs: Box::new(Node::Leaf(false)) + rhs: Box::new(Node::Leaf(false)), }]; add_binary_node(&mut stack, Token::Conjunction); assert_eq!(stack, rhs); @@ -17,28 +17,58 @@ mod tests { #[test] fn ast_to_formula_bool() { let formula = "01&"; - assert_eq!(Node::::ast_to_formula(&Node::::parse_formula(formula)), formula); + assert_eq!( + Node::::ast_to_formula(&Node::::parse_formula(formula)), + formula + ); let formula = "01&00|&"; - assert_eq!(Node::::ast_to_formula(&Node::::parse_formula(formula)), formula); + assert_eq!( + Node::::ast_to_formula(&Node::::parse_formula(formula)), + formula + ); let formula = "01&00|&11^&"; - assert_eq!(Node::::ast_to_formula(&Node::::parse_formula(formula)), formula); + assert_eq!( + Node::::ast_to_formula(&Node::::parse_formula(formula)), + formula + ); let formula = "01&00|&11=^"; - assert_eq!(Node::::ast_to_formula(&Node::::parse_formula(formula)), formula); + assert_eq!( + Node::::ast_to_formula(&Node::::parse_formula(formula)), + formula + ); let formula = "01&00|&0!="; - assert_eq!(Node::::ast_to_formula(&Node::::parse_formula(formula)), formula); + assert_eq!( + Node::::ast_to_formula(&Node::::parse_formula(formula)), + formula + ); } #[test] fn ast_to_formula_char() { let formula = "AB&"; - assert_eq!(Node::::ast_to_formula(&Node::::parse_formula(formula)), formula); + assert_eq!( + Node::::ast_to_formula(&Node::::parse_formula(formula)), + formula + ); let formula = "AB&CD|&"; - assert_eq!(Node::::ast_to_formula(&Node::::parse_formula(formula)), formula); + assert_eq!( + Node::::ast_to_formula(&Node::::parse_formula(formula)), + formula + ); let formula = "AB&AC|&DE^&"; - assert_eq!(Node::::ast_to_formula(&Node::::parse_formula(formula)), formula); + assert_eq!( + Node::::ast_to_formula(&Node::::parse_formula(formula)), + formula + ); let formula = "AB&CD|&EF=^"; - assert_eq!(Node::::ast_to_formula(&Node::::parse_formula(formula)), formula); + assert_eq!( + Node::::ast_to_formula(&Node::::parse_formula(formula)), + formula + ); let formula = "AB&CD|&E!="; - assert_eq!(Node::::ast_to_formula(&Node::::parse_formula(formula)), formula); + assert_eq!( + Node::::ast_to_formula(&Node::::parse_formula(formula)), + formula + ); } -} \ No newline at end of file +} diff --git a/src/boolean_evaluation.rs b/src/boolean_evaluation.rs index b51b3f5..a61b599 100644 --- a/src/boolean_evaluation.rs +++ b/src/boolean_evaluation.rs @@ -1,6 +1,6 @@ mod tests; -use crate::ast::{ Token, Node }; +use crate::ast::{Node, Token}; fn compute(operator: Token, lhs: bool, rhs: bool) -> bool { match operator { @@ -9,7 +9,7 @@ fn compute(operator: Token, lhs: bool, rhs: bool) -> bool { Token::Disjunction => lhs | rhs, Token::ExclusiveDisjunction => lhs ^ rhs, Token::MaterialCondition => !(lhs && !rhs), - Token::LogicalEquivalence => lhs == rhs + Token::LogicalEquivalence => lhs == rhs, } } @@ -24,4 +24,4 @@ fn evaluate(tree: Node) -> bool { pub fn eval_formula(formula: &str) -> bool { let tree = Node::::parse_formula(formula); evaluate(tree) -} \ No newline at end of file +} diff --git a/src/boolean_evaluation/tests.rs b/src/boolean_evaluation/tests.rs index 2430f40..1bf95a3 100644 --- a/src/boolean_evaluation/tests.rs +++ b/src/boolean_evaluation/tests.rs @@ -22,7 +22,10 @@ mod tests { assert_eq!(eval_formula("1!!"), true); assert_eq!(eval_formula("0!!"), false); assert_eq!(eval_formula("0!!!"), true); - assert_eq!(eval_formula("1!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"), true); + assert_eq!( + eval_formula("1!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"), + true + ); } #[test] diff --git a/src/gray_code.rs b/src/gray_code.rs index 108ea83..b8126ad 100644 --- a/src/gray_code.rs +++ b/src/gray_code.rs @@ -10,4 +10,3 @@ pub fn gray_code(n: u32) -> u32 { } result } - diff --git a/src/gray_code/tests.rs b/src/gray_code/tests.rs index 7903e01..6b4d321 100644 --- a/src/gray_code/tests.rs +++ b/src/gray_code/tests.rs @@ -20,6 +20,6 @@ mod tests { fn msb_u32() { assert_eq!(gray_code(3_000_000_000), 3_954_733_312); assert_eq!(gray_code(2_147_483_648), 3_221_225_472); - assert_eq!(gray_code(4_294_967_295), 2_147_483_648); + assert_eq!(gray_code(4_294_967_295), 2_147_483_648); } } diff --git a/src/main.rs b/src/main.rs index e793fc2..588a634 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,10 +1,10 @@ mod adder; -mod multiplier; -mod gray_code; -mod boolean_evaluation; -mod truth_table; mod ast; +mod boolean_evaluation; +mod gray_code; +mod multiplier; mod negation_normal_form; +mod truth_table; use gray_code::gray_code; use truth_table::print_truth_table; diff --git a/src/multiplier.rs b/src/multiplier.rs index 2e208af..2201b18 100644 --- a/src/multiplier.rs +++ b/src/multiplier.rs @@ -4,7 +4,7 @@ use crate::adder::adder; pub fn multiplier(a: u32, b: u32) -> u32 { let mut result = 0; - + for i in 0..32 { if a >> i & 1 == 1 { result = adder(result, b << i); diff --git a/src/negation_normal_form.rs b/src/negation_normal_form.rs index 2da9cb1..2a63e8d 100644 --- a/src/negation_normal_form.rs +++ b/src/negation_normal_form.rs @@ -2,76 +2,8 @@ mod tests; use crate::ast::Node; -// fn cancel_double_negation(ast: &mut Node, parent: Option<&mut Node>) -> Node { -// match ast { -// Node::Unary { operator: _, operand } => { -// if let Some(node) = parent { - -// } else { -// *ast = cancel_double_negation(&mut *operand, Some(ast)); -// } -// }, -// Node::Binary { operator: _, lhs, rhs } => { -// *ast = cancel_double_negation(&mut *lhs, None); -// *ast = cancel_double_negation(&mut *rhs, None); -// }, -// Node::Leaf(c) => (), -// } - -// ast -// } - -// fn cancel_double_negation(ast: Node) { -// let mut new_ast = ast.clone(); - -// fn recursion(ast: &mut Node, node_count: usize) { -// match ast { -// Node::Unary { operator: _, operand } => { -// recursion(&mut *operand, node_count + 1); -// }, -// Node::Binary { operator: _, lhs, rhs } => { -// recursion(&mut *lhs, node_count + 1); -// recursion(&mut *rhs, node_count + 1); -// }, -// Node::Leaf(c) => (), -// } -// } - -// recursion(&mut new_ast, 0); - -// new_ast -// } - fn negation_normal_form(formula: &str) -> String { let mut ast = Node::::parse_formula(formula); - // let mut tmp = Node::::parse_formula((formula.to_string() + "!").as_str()); - // let mut clone = ast.clone(); - - // while Node::::ast_to_formula(&clone) != Node::::ast_to_formula(&tmp) { - // let copy = ast.clone(); - // clone = ast.clone(); - - // dbg!(&ast); - - // tmp = match copy { - // Node::Unary { operator: _, operand } => { - // match *operand { - // Node::Unary { operator: _, operand } => { - // println!("salut"); - // dbg!(&*operand); - // *operand - // } - // Node::Binary { operator: _, lhs: _, rhs: _ } => ast, - // Node::Leaf(_) => ast, - - // } - // } - // Node::Binary { operator: _, lhs: _, rhs: _ } => ast, - // Node::Leaf(_) => ast, - // }; - - // ast = tmp.clone(); - // } ast.simplify(); Node::::ast_to_formula(&ast) -} \ No newline at end of file +} diff --git a/src/negation_normal_form/tests.rs b/src/negation_normal_form/tests.rs index 3eafadc..11a1f9c 100644 --- a/src/negation_normal_form/tests.rs +++ b/src/negation_normal_form/tests.rs @@ -13,21 +13,56 @@ mod tests { #[test] fn double_neg() { - assert_eq!(negation_normal_form("A!!A&"), "AA&"); - assert_eq!(negation_normal_form("B!!B!!&"), "BB&"); - assert_eq!(negation_normal_form("C!!C!&"), "CC!&"); - assert_eq!(negation_normal_form("D!!D&!!!!"), "DD&"); - assert_eq!(negation_normal_form("E!!E!!!!&!!"), "EE&"); - assert_eq!(negation_normal_form("F!!F!&!!!!!!!!"), "FF!&"); + assert_eq!(negation_normal_form("A!!Z&"), "AZ&"); + assert_eq!(negation_normal_form("B!!Z!!&"), "BZ&"); + assert_eq!(negation_normal_form("C!!Z!&"), "CZ!&"); + assert_eq!(negation_normal_form("D!!Z&!!!!"), "DZ&"); + assert_eq!(negation_normal_form("E!!Z!!!!&!!"), "EZ&"); + assert_eq!(negation_normal_form("F!!Z!&!!!!!!!!"), "FZ!&"); } #[test] fn neg_and() { - assert_eq!(negation_normal_form("AB&!"), "A!B!|"); + assert_eq!(negation_normal_form("AZ&!"), "A!Z!|"); + assert_eq!(negation_normal_form("BZ&!BZ&!&"), "B!Z!|B!Z!|&"); + assert_eq!(negation_normal_form("CZ&!CZ&!&!"), "CZ&CZ&|"); } #[test] fn neg_or() { - assert_eq!(negation_normal_form("AB|!"), "A!B!&"); + assert_eq!(negation_normal_form("AZ|!"), "A!Z!&"); + assert_eq!(negation_normal_form("BZ|!BZ|!|"), "B!Z!&B!Z!&|"); + assert_eq!(negation_normal_form("CZ|!CZ|!|!"), "CZ|CZ|&"); } -} \ No newline at end of file + + #[test] + fn material_condition() { + assert_eq!(negation_normal_form("AZ>"), "A!Z|"); + assert_eq!(negation_normal_form("BZ>!"), "BZ!&"); + } + + #[test] + fn exclusive_disjunction() { + assert_eq!(negation_normal_form("AZ^"), "AZ|A!Z!|&"); + assert_eq!(negation_normal_form("BZ^!"), "B!Z!&BZ&|"); + } + + #[test] + fn logical_equivalence() { + assert_eq!(negation_normal_form("AZ="), "A!Z|Z!A|&"); + assert_eq!(negation_normal_form("BZ=!"), "BZ!&ZB!&|"); + } + + #[test] + fn subject_tests() { + assert_eq!(negation_normal_form("AB&!"), "A!B!|"); + assert_eq!(negation_normal_form("AB|!"), "A!B!&"); + assert_eq!(negation_normal_form("AB>"), "A!B|"); + assert_eq!(negation_normal_form("AB|C&!"), "A!B!&C!|"); + } + + #[test] + fn complex_tests() { + assert_eq!("A", "A"); + } +} diff --git a/src/truth_table.rs b/src/truth_table.rs index 284761b..c3d2398 100644 --- a/src/truth_table.rs +++ b/src/truth_table.rs @@ -1,7 +1,7 @@ mod tests; +use crate::ast::{add_binary_node, add_unary_node, Node, Token}; use std::collections::HashSet; -use crate::ast::{ Token, Node, add_unary_node, add_binary_node }; fn parse_formula(formula: &str) -> Node { let mut stack = vec![]; @@ -15,7 +15,7 @@ fn parse_formula(formula: &str) -> Node { '^' => add_binary_node(&mut stack, Token::ExclusiveDisjunction), '>' => add_binary_node(&mut stack, Token::MaterialCondition), '=' => add_binary_node(&mut stack, Token::LogicalEquivalence), - _ => panic!("Error: {} is not a valid character", c) + _ => panic!("Error: {} is not a valid character", c), } } stack.pop().unwrap() @@ -28,7 +28,7 @@ fn compute(operator: Token, lhs: bool, rhs: bool) -> bool { Token::Disjunction => lhs | rhs, Token::ExclusiveDisjunction => lhs ^ rhs, Token::MaterialCondition => !(lhs && !rhs), - Token::LogicalEquivalence => lhs == rhs + Token::LogicalEquivalence => lhs == rhs, } } @@ -45,7 +45,9 @@ fn get_hashset(formula: &str) -> HashSet { for c in formula.chars() { match c { - 'A'..='Z' => { hashset.insert(c); }, + 'A'..='Z' => { + hashset.insert(c); + } '!' | '&' | '|' | '^' | '>' | '=' => (), _ => panic!("Error: {} is not a valid character", c), } @@ -61,8 +63,16 @@ fn eval_formula(formula: &str) -> bool { fn recursive_fn(formula: &str, mut vec: Vec, format: String) { let char = vec.pop(); if let Some(c) = char { - recursive_fn(formula.replace(c, "0").as_str(), vec.clone(), format!("{format} 0 |")); - recursive_fn(formula.replace(c, "1").as_str(), vec.clone(), format!("{format} 1 |")); + recursive_fn( + formula.replace(c, "0").as_str(), + vec.clone(), + format!("{format} 0 |"), + ); + recursive_fn( + formula.replace(c, "1").as_str(), + vec.clone(), + format!("{format} 1 |"), + ); } else { match eval_formula(formula) { false => println!("{format} 0 |"), @@ -89,5 +99,5 @@ pub fn print_truth_table(formula: &str) { println!("{separator}"); //dbg!(vec.clone()); recursive_fn(formula, vec.into_iter().rev().collect(), String::from("|")); - // call eval formula a lot -} \ No newline at end of file + // call eval formula a lot +}