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

Merged a few branches in absorption law together

Browse Source
This commit is contained in:
Martin Berg Alstad 2024-07-04 13:05:52 +02:00
parent 7044dc304d
commit 9b6a24e222
2 changed files with 15 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/expressions/operator.rs
View File

@ -16,4 +16,12 @@ impl BinaryOperator {
BinaryOperator::Implication => !left || right, BinaryOperator::Implication => !left || right,
} }
} }
pub fn is_and(&self) -> bool {
matches!(self, BinaryOperator::And)
}
pub fn is_or(&self) -> bool {
matches!(self, BinaryOperator::Or)
}
} }

42
src/expressions/simplify.rs
View File

@ -124,6 +124,7 @@ impl From<SimplifyOptions> for Options {
} }
} }
// TODO refactor, remove unnecessary code and split up into smaller functions
impl Expression { impl Expression {
// TODO better track of operations // TODO better track of operations
pub fn simplify(&self, options: Options) -> (Self, Vec<Operation>) { pub fn simplify(&self, options: Options) -> (Self, Vec<Operation>) {
@ -228,22 +229,22 @@ 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, right }
if left.is_in(right) && right.is_or() => { if operator.is_and() && (right.is_in(left) && left.is_and() || 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, right }
if right.is_in(left) && left.is_or() => { if operator.is_and() && (right.is_in(left) && left.is_or() || left.is_in(right) && right.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, right }
if right.is_in(left) && left.is_and() => { if operator.is_or() && (right.is_in(left) && (left.is_and() || left.is_or()) || left.is_in(right) && right.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);
} }
@ -256,35 +257,6 @@ impl Expression {
} }
left.absorption_law(operations, ignore_case) 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) {
operations.push(operation);
}
left.absorption_law(operations, ignore_case)
}
Expression::Binary { left, operator, right } => binary( Expression::Binary { left, operator, right } => binary(
left.absorption_law(operations, ignore_case), left.absorption_law(operations, ignore_case),
*operator, *operator,