martials/simplify_truths
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed bugs in simplify

Browse Source
This commit is contained in:
Martin Berg Alstad 2024-06-28 17:58:56 +02:00
parent ba4f3b78ad
commit 1c6d400f4a
2 changed files with 81 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/expressions/expression.rs
View File

@ -79,11 +79,11 @@ impl Expression {
} }
} }
pub fn is_or_expression(&self) -> bool { pub fn is_or(&self) -> bool {
matches!(self, Expression::Binary { operator: BinaryOperator::Or, .. }) matches!(self, Expression::Binary { operator: BinaryOperator::Or, .. })
} }
pub fn is_and_expression(&self) -> bool { pub fn is_and(&self) -> bool {
matches!(self, Expression::Binary { operator: BinaryOperator::And, .. }) matches!(self, Expression::Binary { operator: BinaryOperator::And, .. })
} }
} }

89
src/expressions/simplify.rs
View File

@ -21,9 +21,10 @@ pub enum Law {
CommutativeLaw, CommutativeLaw,
} }
// TODO refactor
#[macro_export] #[macro_export]
macro_rules! absorption_law_opposites { macro_rules! absorption_law_opposites {
($left:expr, $right:expr, $operations:expr, $op:pat, $func:expr, $ignore_case:expr) => { ($left:expr, $right:expr, $operations:expr, $this_op:pat, $op:pat, $func:expr, $ignore_case:expr) => {
{ {
let before = $func($left.clone(), $right.clone()); let before = $func($left.clone(), $right.clone());
match ($left.as_ref(), $right.as_ref()) { match ($left.as_ref(), $right.as_ref()) {
@ -31,7 +32,22 @@ macro_rules! absorption_law_opposites {
let result = evaluate_equals_or_opposites($left.as_ref(), right_left, right_right, $func, $ignore_case, $operations).unwrap_or( let result = evaluate_equals_or_opposites($left.as_ref(), right_left, right_right, $func, $ignore_case, $operations).unwrap_or(
$func($left.absorption_law($operations, $ignore_case), $right.absorption_law($operations, $ignore_case)) $func($left.absorption_law($operations, $ignore_case), $right.absorption_law($operations, $ignore_case))
); );
dbg!(before.to_string(), result.to_string()); if let Some(operation) = Operation::new(&before, &result, Law::AbsorptionLaw) {
$operations.push(operation);
}
result
}
(_, Expression::Binary { left: right_left, operator: $this_op, .. })
if $left.opposite_eq(right_left, $ignore_case) => {
let result = $func($left.clone(), right_left.clone());
if let Some(operation) = Operation::new(&before, &result, Law::AbsorptionLaw) {
$operations.push(operation);
}
result
}
(_, Expression::Binary { right: right_right, operator: $this_op, .. })
if $left.opposite_eq(right_right, $ignore_case) => {
let result = $func($left.clone(), right_right.clone());
if let Some(operation) = Operation::new(&before, &result, Law::AbsorptionLaw) { if let Some(operation) = Operation::new(&before, &result, Law::AbsorptionLaw) {
$operations.push(operation); $operations.push(operation);
} }
@ -41,7 +57,22 @@ macro_rules! absorption_law_opposites {
let result = evaluate_equals_or_opposites($right.as_ref(), left_left, left_right, $func, $ignore_case, $operations).unwrap_or( let result = evaluate_equals_or_opposites($right.as_ref(), left_left, left_right, $func, $ignore_case, $operations).unwrap_or(
$func($left.absorption_law($operations, $ignore_case), $right.absorption_law($operations, $ignore_case)) $func($left.absorption_law($operations, $ignore_case), $right.absorption_law($operations, $ignore_case))
); );
dbg!(before.to_string(), result.to_string()); if let Some(operation) = Operation::new(&before, &result, Law::AbsorptionLaw) {
$operations.push(operation);
}
result
}
(Expression::Binary { left: left_left, operator: $this_op, .. }, _)
if $right.opposite_eq(left_left, $ignore_case) => {
let result = $func($right.clone(), left_left.clone());
if let Some(operation) = Operation::new(&before, &result, Law::AbsorptionLaw) {
$operations.push(operation);
}
result
}
(Expression::Binary { right: left_right, operator: $this_op, .. }, _)
if $right.opposite_eq(left_right, $ignore_case) => {
let result = $func($right.clone(), left_right.clone());
if let Some(operation) = Operation::new(&before, &result, Law::AbsorptionLaw) { if let Some(operation) = Operation::new(&before, &result, Law::AbsorptionLaw) {
$operations.push(operation); $operations.push(operation);
} }
@ -198,28 +229,57 @@ impl Expression {
left.absorption_law(operations, ignore_case) left.absorption_law(operations, ignore_case)
} }
Expression::Binary { left, operator: BinaryOperator::And, right } Expression::Binary { left, operator: BinaryOperator::And, right }
if left.is_in(right) && right.is_or_expression() => { if left.is_in(right) && right.is_or() => {
if let Some(operation) = Operation::new(self, left, Law::AbsorptionLaw) { if let Some(operation) = Operation::new(self, left, Law::AbsorptionLaw) {
operations.push(operation); operations.push(operation);
} }
left.absorption_law(operations, ignore_case) left.absorption_law(operations, ignore_case)
} }
Expression::Binary { left, operator: BinaryOperator::And, right } Expression::Binary { left, operator: BinaryOperator::And, right }
if right.is_in(left) && left.is_or_expression() => { if right.is_in(left) && left.is_or() => {
if let Some(operation) = Operation::new(self, right, Law::AbsorptionLaw) { if let Some(operation) = Operation::new(self, right, Law::AbsorptionLaw) {
operations.push(operation); operations.push(operation);
} }
right.absorption_law(operations, ignore_case) right.absorption_law(operations, ignore_case)
} }
Expression::Binary { left, operator: BinaryOperator::Or, right } Expression::Binary { left, operator: BinaryOperator::Or, right }
if right.is_in(left) && left.is_and_expression() => { if right.is_in(left) && left.is_and() => {
if let Some(operation) = Operation::new(self, right, Law::AbsorptionLaw) { if let Some(operation) = Operation::new(self, right, Law::AbsorptionLaw) {
operations.push(operation); operations.push(operation);
} }
right.absorption_law(operations, ignore_case) right.absorption_law(operations, ignore_case)
} }
Expression::Binary { left, operator: BinaryOperator::Or, right } Expression::Binary { left, operator: BinaryOperator::Or, right }
if left.is_in(right) && right.is_and_expression() => { if left.is_in(right) && right.is_and() => {
if let Some(operation) = Operation::new(self, left, Law::AbsorptionLaw) {
operations.push(operation);
}
left.absorption_law(operations, ignore_case)
}
Expression::Binary { left, operator: BinaryOperator::Or, right }
if left.is_in(right) && right.is_or() => {
if let Some(operation) = Operation::new(self, left, Law::AbsorptionLaw) {
operations.push(operation);
}
right.absorption_law(operations, ignore_case)
}
Expression::Binary { left, operator: BinaryOperator::Or, right }
if right.is_in(left) && left.is_or() => {
if let Some(operation) = Operation::new(self, right, Law::AbsorptionLaw) {
operations.push(operation);
}
right.absorption_law(operations, ignore_case)
}
// TODO remove And from pattern and call matches instead of .is_and()
Expression::Binary { left, operator: BinaryOperator::And, right }
if left.is_in(right) && right.is_and() => {
if let Some(operation) = Operation::new(self, right, Law::AbsorptionLaw) {
operations.push(operation);
}
right.absorption_law(operations, ignore_case)
}
Expression::Binary { left, operator: BinaryOperator::And, right }
if right.is_in(left) && left.is_and() => {
if let Some(operation) = Operation::new(self, left, Law::AbsorptionLaw) { if let Some(operation) = Operation::new(self, left, Law::AbsorptionLaw) {
operations.push(operation); operations.push(operation);
} }
@ -239,10 +299,10 @@ impl Expression {
match self { match self {
Expression::Binary { left, operator: BinaryOperator::And, right } => { Expression::Binary { left, operator: BinaryOperator::And, right } => {
// TODO Refactor duplicate code with absorption_law! // TODO Refactor duplicate code with absorption_law!
absorption_law_opposites!(left, right, operations, BinaryOperator::Or, and, ignore_case) absorption_law_opposites!(left, right, operations, BinaryOperator::And, BinaryOperator::Or, and, ignore_case)
} }
Expression::Binary { left, operator: BinaryOperator::Or, right } => { Expression::Binary { left, operator: BinaryOperator::Or, right } => {
absorption_law_opposites!(left, right, operations, BinaryOperator::And, or, ignore_case) absorption_law_opposites!(left, right, operations, BinaryOperator::Or, BinaryOperator::And, or, ignore_case)
} }
Expression::Binary { left, operator, right } => binary( Expression::Binary { left, operator, right } => binary(
left.absorb_opposites(operations, ignore_case), left.absorb_opposites(operations, ignore_case),
@ -507,7 +567,16 @@ mod tests {
#[test] #[test]
fn test_absorption_law_duplicate() { fn test_absorption_law_duplicate() {
let mut operations = vec![]; let mut operations = vec![];
let expression = or(not(atomic("a")), or(not(atomic("a")), or(atomic("a"), atomic("b")))).absorption_law(&mut operations, false); let expression = or(
not(atomic("a")),
or(
not(atomic("a")),
or(
atomic("a"),
atomic("b"),
),
),
).absorption_law(&mut operations, false);
assert_eq!(expression, or(not(atomic("a")), or(atomic("a"), atomic("b")))); assert_eq!(expression, or(not(atomic("a")), or(atomic("a"), atomic("b"))));
assert_eq!(operations.len(), 1); assert_eq!(operations.len(), 1);
} }