diff --git a/src/Main.java b/src/Main.java index 0bb0b08..9a1ea3c 100644 --- a/src/Main.java +++ b/src/Main.java @@ -31,9 +31,17 @@ public static void main(String[] args) { // sandbox1(); // sandbox2(); - sandbox3(); +// sandbox3(); // sandbox4(); // ProofSystem.debug(); + ResourceVariable A = new ResourceVariable("A", Utils.INT, 1); + ResourceVariable B = new ResourceVariable("B", Utils.INT, 1); + ResourceVariable C = new ResourceVariable("C", Utils.INT, 1); + ResourceVariable D = new ResourceVariable("D", Utils.INT, 1); + ResourceVariable E = new ResourceVariable("E", Utils.INT, 1); + + DependencyTerm t1 = new DependencyTerm(A, B, C, D, E); + System.out.println(t1); } static void sandbox1() { diff --git a/src/models/terms/DependencyTerm.java b/src/models/terms/DependencyTerm.java index de8d75e..d24b955 100644 --- a/src/models/terms/DependencyTerm.java +++ b/src/models/terms/DependencyTerm.java @@ -1,5 +1,9 @@ package models.terms; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.IntStream; + import lombok.Getter; import models.algebra.Symbol; @@ -7,25 +11,54 @@ public class DependencyTerm extends EvaluatableTerm{ private EvaluatableTerm dependingTerm; - private ResourceVariable dependedVariable; - private EvaluatableTerm argumentTerm; + private List dependedTerms = new ArrayList<>(); + private List argumentTerms = new ArrayList<>(); -// public DependencyTerm(int order) { -// super(new Symbol(":", 3), order); + +// public DependencyTerm(EvaluatableTerm dependingTerm, EvaluatableTerm dependedTerm, EvaluatableTerm argumentTerm) { +// super( +// new Symbol(":", 3), +// dependedTerm.getOrder() == argumentTerm.getOrder() ? dependedTerm.getOrder() : dependedTerm.getOrder() - 1, +// dependingTerm.getSize() + argumentTerm.getSize() + dependedTerm.getSize() +// ); +// this.dependingTerm = dependingTerm; +// this.dependedTerms.add(dependedTerm); +// this.argumentTerms.add(argumentTerm); +// addChild(dependingTerm); +// addChild(dependedTerm); +// addChild(argumentTerm); // } - public DependencyTerm(EvaluatableTerm dependingTerm, ResourceVariable dependedVariable, EvaluatableTerm argumentTerm) { + public DependencyTerm(EvaluatableTerm dependingTerm, List dependedTerms, List argumentTerms) { super( - new Symbol(":", 3), - dependedVariable.getOrder() == argumentTerm.getOrder() ? dependedVariable.getOrder() : dependedVariable.getOrder() - 1, - dependingTerm.getSize() + argumentTerm.getSize() + dependedVariable.getSize() + new Symbol(":", 1 + dependedTerms.size() + argumentTerms.size()), + dependedTerms.get(0).getOrder() == argumentTerms.get(0).getOrder() ? dependedTerms.get(0).getOrder() : argumentTerms.get(0).getOrder() - 1, + dependingTerm.getSize() + argumentTerms.get(0).getSize() + dependedTerms.get(0).getSize() ); + boolean dependedTermsOrderCheck = dependedTerms.stream().allMatch(e -> e.getOrder() == dependedTerms.get(0).getOrder()); + boolean argumentTermsOrderCheck = argumentTerms.stream().allMatch(e -> e.getOrder() == argumentTerms.get(0).getOrder()); + if (! (dependedTermsOrderCheck && argumentTermsOrderCheck)) { + throw new RuntimeException("Orders are not all equals"); + } + if (dependedTerms.size() != argumentTerms.size()) { + throw new RuntimeException("Size not equals"); + } this.dependingTerm = dependingTerm; - this.dependedVariable = dependedVariable; - this.argumentTerm = argumentTerm; + this.dependedTerms = new ArrayList<>(dependedTerms); + this.argumentTerms = new ArrayList<>(argumentTerms); addChild(dependingTerm); - addChild(dependedVariable); - addChild(argumentTerm); + for (int i = 0; i < dependedTerms.size(); i++) { + addChild(dependedTerms.get(i)); + addChild(argumentTerms.get(i)); + } + } + + public DependencyTerm(EvaluatableTerm dependingTerm, EvaluatableTerm ...terms) { + this( + dependingTerm, + IntStream.range(0, terms.length).filter(i -> i % 2 == 0).mapToObj(i -> terms[i]).toList(), + IntStream.range(0, terms.length).filter(i -> i % 2 == 1).mapToObj(i -> terms[i]).toList() + ); } @Override @@ -42,69 +75,54 @@ @Override public void selfLinearRightNormalize() { - if(dependingTerm instanceof ResourceVariable || dependingTerm instanceof SetEvaluatableTerm) { - argumentTerm.selfLinearRightNormalize(); - return; - } - DependencyTerm dependencyTerm = (DependencyTerm) dependingTerm; - if(! dependencyTerm.isLinearRightNormalized()) { - dependencyTerm.selfLinearRightNormalize(); - } - if(! isLinearRightNormalized()) { - EvaluatableTerm childArgumentTerm = dependencyTerm.getArgumentTerm(); - DependencyTerm nextDependencyTerm = new DependencyTerm(childArgumentTerm, dependedVariable, argumentTerm); - this.dependingTerm = dependencyTerm.getDependingTerm(); - this.dependedVariable = dependencyTerm.getDependedVariable(); - this.argumentTerm = nextDependencyTerm; - this.setChild(2, nextDependencyTerm); - this.setChild(0, dependencyTerm.getDependingTerm()); - this.setChild(1, dependencyTerm.getDependedVariable()); - } - argumentTerm.selfLinearRightNormalize(); +// if(dependingTerm instanceof ResourceVariable || dependingTerm instanceof SetEvaluatableTerm) { +// argumentTerm.selfLinearRightNormalize(); +// return; +// } +// DependencyTerm dependencyTerm = (DependencyTerm) dependingTerm; +// if(! dependencyTerm.isLinearRightNormalized()) { +// dependencyTerm.selfLinearRightNormalize(); +// } +// if(! isLinearRightNormalized()) { +// EvaluatableTerm childArgumentTerm = dependencyTerm.getArgumentTerm(); +// DependencyTerm nextDependencyTerm = new DependencyTerm(childArgumentTerm, dependedVariable, argumentTerm); +// this.dependingTerm = dependencyTerm.getDependingTerm(); +// this.dependedVariable = dependencyTerm.getDependedVariable(); +// this.argumentTerm = nextDependencyTerm; +// this.setChild(2, nextDependencyTerm); +// this.setChild(0, dependencyTerm.getDependingTerm()); +// this.setChild(1, dependencyTerm.getDependedVariable()); +// } +// argumentTerm.selfLinearRightNormalize(); } private boolean isLinearRightNormaled(int depth) { - if(dependingTerm instanceof ResourceVariable || dependingTerm instanceof SetEvaluatableTerm) { - return dependingTerm.getOrder() == dependedVariable.getOrder(); - } - DependencyTerm dependencyTerm = (DependencyTerm) dependingTerm; - if( - dependencyTerm.isLinearRightNormaled(depth + 1) && - dependencyTerm.getDependedVariable().getOrder() - 1 == dependedVariable.getOrder() && - dependencyTerm.getOrder() == dependedVariable.getOrder() && - argumentTerm.getOrder() <= dependencyTerm.getOrder() && - depth == 0 - ) { - return true; - } - if( - dependencyTerm.isLinearRightNormaled(depth + 1) && - dependencyTerm.getDependedVariable().getOrder() - 1 == dependedVariable.getOrder() && - dependencyTerm.getOrder() == dependedVariable.getOrder() && - argumentTerm.getOrder() < dependencyTerm.getOrder() - ) { - return true; - } +// if(dependingTerm instanceof ResourceVariable || dependingTerm instanceof SetEvaluatableTerm) { +// return dependingTerm.getOrder() == dependedVariable.getOrder(); +// } +// DependencyTerm dependencyTerm = (DependencyTerm) dependingTerm; +// if( +// dependencyTerm.isLinearRightNormaled(depth + 1) && +// dependencyTerm.getDependedVariable().getOrder() - 1 == dependedVariable.getOrder() && +// dependencyTerm.getOrder() == dependedVariable.getOrder() && +// argumentTerm.getOrder() <= dependencyTerm.getOrder() && +// depth == 0 +// ) { +// return true; +// } +// if( +// dependencyTerm.isLinearRightNormaled(depth + 1) && +// dependencyTerm.getDependedVariable().getOrder() - 1 == dependedVariable.getOrder() && +// dependencyTerm.getOrder() == dependedVariable.getOrder() && +// argumentTerm.getOrder() < dependencyTerm.getOrder() +// ) { +// return true; +// } return false; } - public void setDependingTerm(EvaluatableTerm newTerm) { - setChild(0, newTerm); - this.dependingTerm = newTerm; - } - - public void setDependedVariable(ResourceVariable newVariable) { - setChild(1, newVariable); - this.dependedVariable = newVariable; - } - - public void setArgumentTerm(EvaluatableTerm newTerm) { - setChild(2, newTerm); - this.argumentTerm = newTerm; - } - @Override public String toString() { @@ -112,9 +130,14 @@ sb.append('['); sb.append(getDependingTerm().toString()); sb.append(" : "); - sb.append(getDependedVariable().toString()); - sb.append(" -> "); - sb.append(argumentTerm.toString()); + for (int i = 0; i < dependedTerms.size(); i++) { + sb.append(dependedTerms.get(i).toString()); + sb.append(" -> "); + sb.append(argumentTerms.get(i).toString()); + sb.append(", "); + } + sb.deleteCharAt(sb.length() - 1); + sb.deleteCharAt(sb.length() - 1); sb.append(']'); return sb.toString(); } @@ -125,9 +148,13 @@ sb.append('['); sb.append(getDependingTerm().toStringWithOrder()); sb.append(" : "); - sb.append(getDependedVariable().toStringWithOrder()); - sb.append(" -> "); - sb.append(argumentTerm.toStringWithOrder()); + for (int i = 0; i < dependedTerms.size(); i++) { + sb.append(dependedTerms.get(i).toStringWithOrder()); + sb.append(" -> "); + sb.append(argumentTerms.get(i).toStringWithOrder()); + sb.append(", "); + } + sb.deleteCharAt(sb.length() - 1); sb.append(']'); sb.append('('); sb.append(order); @@ -141,9 +168,10 @@ return false; } DependencyTerm term = (DependencyTerm) another; + return dependingTerm.equals(term.getDependingTerm()) && - dependedVariable.equals(term.getDependedVariable()) && - argumentTerm.equals(term.getArgumentTerm()); + dependedTerms.stream().sorted().toList().equals(term.getDependedTerms().stream().sorted().toList()) && + argumentTerms.stream().sorted().toList().equals(term.getArgumentTerms().stream().sorted().toList()); } @Override @@ -155,8 +183,8 @@ public Object clone() { return new DependencyTerm( (EvaluatableTerm) dependingTerm.clone(), - (ResourceVariable) dependedVariable.clone(), - (EvaluatableTerm) argumentTerm.clone() + new ArrayList<>(dependedTerms), + new ArrayList<>(argumentTerms) ); } diff --git a/src/models/terms/EvaluatableTerm.java b/src/models/terms/EvaluatableTerm.java index 59641a9..84169f6 100644 --- a/src/models/terms/EvaluatableTerm.java +++ b/src/models/terms/EvaluatableTerm.java @@ -1,8 +1,6 @@ package models.terms; -import exceptions.IllegalTypeException; import models.algebra.Symbol; -import models.algebra.Type; public abstract class EvaluatableTerm extends RDLTerm{ @@ -21,49 +19,4 @@ public abstract EvaluatableTerm linearRightNormalize(); public abstract void selfLinearRightNormalize(); - public static ResourceVariable of(String name, Type type, int order) { - return new ResourceVariable(name, type, order); - } - - public static DependencyTerm of(EvaluatableTerm term, ResourceVariable variable, EvaluatableTerm valueTerm) { - return new DependencyTerm(term, variable, valueTerm); - } - - public static EvaluatableTerm of(EvaluatableTerm term, ResourceVariable variable, EvaluatableTerm valueTerm, int order) { - if(variable.getOrder() == valueTerm.getOrder() && variable.getOrder() == order) { - return new DependencyTerm(term, variable, valueTerm); - } else if(variable.getOrder() -1 == order) { - return new DependencyTerm(term, variable, valueTerm); - } else { - return new SetEvaluatableTerm(new DependencyTerm(term, variable, valueTerm), order); - } - } - - public static DependencyTerm of(Dependency dependency, EvaluatableTerm argumentTerm) { - RDLTerm term = dependency.getDependingTerm(); - if(! (term instanceof EvaluatableTerm)) { - throw new IllegalTypeException(); - } - return new DependencyTerm((EvaluatableTerm) term, dependency.getDependedVariable(), argumentTerm); - } - - public static EvaluatableTerm of(Dependency dependency, EvaluatableTerm argumentTerm, int order) { - RDLTerm term = dependency.getDependingTerm(); - if(! (term instanceof EvaluatableTerm)) { - throw new IllegalTypeException(); - } - ResourceVariable variable = dependency.getDependedVariable(); - if(variable.getOrder() == argumentTerm.getOrder() && variable.getOrder() == order) { - return new DependencyTerm((EvaluatableTerm) term, variable, argumentTerm); - } else if(variable.getOrder() - 1 == order) { - return new DependencyTerm((EvaluatableTerm) term, variable, argumentTerm); - } else { - return new SetEvaluatableTerm(new DependencyTerm((EvaluatableTerm) term, variable, argumentTerm), order); - } - } - - public static SetEvaluatableTerm of(EvaluatableTerm term, int order) { - return new SetEvaluatableTerm(term, order); - } - } diff --git a/src/models/terms/RDLTerm.java b/src/models/terms/RDLTerm.java index 9b8a038..629839c 100644 --- a/src/models/terms/RDLTerm.java +++ b/src/models/terms/RDLTerm.java @@ -5,7 +5,7 @@ import models.algebra.Term; @Getter -public abstract class RDLTerm extends Term { +public abstract class RDLTerm extends Term implements Comparable{ protected int order; protected int size; @@ -30,6 +30,11 @@ } @Override + public int compareTo(RDLTerm other) { + return toString().compareTo(other.toString()); + } + + @Override public boolean equals(Object another) { return super.equals(another); } diff --git a/src/tests/terms/EqualsTest.java b/src/tests/terms/EqualsTest.java new file mode 100644 index 0000000..48ebe7e --- /dev/null +++ b/src/tests/terms/EqualsTest.java @@ -0,0 +1,27 @@ +package tests.terms; + +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.Test; + +import models.terms.DependencyTerm; +import models.terms.ResourceVariable; +import tests.Utils; + +public class EqualsTest { + + @Test + void DependencyTermEqualsTest() { + ResourceVariable A = new ResourceVariable("A", Utils.INT, 1); + ResourceVariable B = new ResourceVariable("B", Utils.INT, 1); + ResourceVariable C = new ResourceVariable("C", Utils.INT, 1); + ResourceVariable D = new ResourceVariable("D", Utils.INT, 1); + ResourceVariable E = new ResourceVariable("E", Utils.INT, 1); + + DependencyTerm t1 = new DependencyTerm(A, B, C, D, E); + DependencyTerm t2 = new DependencyTerm(A, D, E, B, C); + assertTrue(t1.equals(t2)); + + } + +} diff --git a/src/tests/terms/LinearRightNormalTest.java b/src/tests/terms/LinearRightNormalTest.java index 27e464b..4491b6a 100644 --- a/src/tests/terms/LinearRightNormalTest.java +++ b/src/tests/terms/LinearRightNormalTest.java @@ -7,6 +7,7 @@ import models.algebra.Type; import models.algebra.Variable; import models.dataConstraintModel.DataConstraintModel; +import models.terms.DependencyTerm; import models.terms.EvaluatableTerm; import models.terms.LinearRightNormalizedType; import models.terms.ResourceVariable; @@ -22,23 +23,23 @@ void linearRightNormalTest() { - ResourceVariable a = EvaluatableTerm.of("A", INT, 2); - ResourceVariable b = EvaluatableTerm.of("B", INT, 2); - ResourceVariable c = EvaluatableTerm.of("C", INT, 2); - ResourceVariable d = EvaluatableTerm.of("D", INT, 2); - ResourceVariable e = EvaluatableTerm.of("E", INT, 2); - ResourceVariable f = EvaluatableTerm.of("F", INT, 2); - ResourceVariable g = EvaluatableTerm.of("G", INT, 1); + ResourceVariable a = new ResourceVariable("A", INT, 2); + ResourceVariable b = new ResourceVariable("B", INT, 2); + ResourceVariable c = new ResourceVariable("C", INT, 2); + ResourceVariable d = new ResourceVariable("D", INT, 2); + ResourceVariable e = new ResourceVariable("E", INT, 2); + ResourceVariable f = new ResourceVariable("F", INT, 2); + ResourceVariable g = new ResourceVariable("G", INT, 1); - EvaluatableTerm te1 = EvaluatableTerm.of(e, f, g); - EvaluatableTerm te2 = EvaluatableTerm.of(c, d, te1); - EvaluatableTerm te3 = EvaluatableTerm.of(a, b, te2); + EvaluatableTerm te1 = new DependencyTerm(e, f, g); + EvaluatableTerm te2 = new DependencyTerm(c, d, te1); + EvaluatableTerm te3 = new DependencyTerm(a, b, te2); //[a:b->[c:d->[e:f->g]]] assertEquals(te3.isLinearRightNormalized(), true); - EvaluatableTerm te4 = EvaluatableTerm.of(a, b, c); - EvaluatableTerm te5 = EvaluatableTerm.of(te4, d, e); - EvaluatableTerm te6 = EvaluatableTerm.of(te5, f, g); + EvaluatableTerm te4 = new DependencyTerm(a, b, c); + EvaluatableTerm te5 = new DependencyTerm(te4, d, e); + EvaluatableTerm te6 = new DependencyTerm(te5, f, g); //[[[a:b->c]:d->e]:f->g] assertEquals(te6.isLinearRightNormalized(), false); } @@ -46,17 +47,17 @@ @Test void linearRightNormalizeTest() { - ResourceVariable a = EvaluatableTerm.of("A", INT, 2); - ResourceVariable b = EvaluatableTerm.of("B", INT, 2); - ResourceVariable c = EvaluatableTerm.of("C", INT, 2); - ResourceVariable d = EvaluatableTerm.of("D", INT, 2); - ResourceVariable e = EvaluatableTerm.of("E", INT, 2); - ResourceVariable f = EvaluatableTerm.of("F", INT, 2); - ResourceVariable g = EvaluatableTerm.of("G", INT, 1); + ResourceVariable a = new ResourceVariable("A", INT, 2); + ResourceVariable b = new ResourceVariable("B", INT, 2); + ResourceVariable c = new ResourceVariable("C", INT, 2); + ResourceVariable d = new ResourceVariable("D", INT, 2); + ResourceVariable e = new ResourceVariable("E", INT, 2); + ResourceVariable f = new ResourceVariable("F", INT, 2); + ResourceVariable g = new ResourceVariable("G", INT, 1); - EvaluatableTerm te1 = EvaluatableTerm.of(a, b, c); - EvaluatableTerm te2 = EvaluatableTerm.of(te1, d, e); - EvaluatableTerm te3 = EvaluatableTerm.of(te2, f, g); + EvaluatableTerm te1 = new DependencyTerm(a, b, c); + EvaluatableTerm te2 = new DependencyTerm(te1, d, e); + EvaluatableTerm te3 = new DependencyTerm(te2, f, g); assertEquals(te3.isLinearRightNormalized(), false); te3.selfLinearRightNormalize(); @@ -65,17 +66,17 @@ @Test void linearRightNomalizedMatchTest() { - ResourceVariable a = EvaluatableTerm.of("A", INT, 2); - ResourceVariable b = EvaluatableTerm.of("B", INT, 2); - ResourceVariable c = EvaluatableTerm.of("C", INT, 2); - ResourceVariable d = EvaluatableTerm.of("D", INT, 2); - ResourceVariable e = EvaluatableTerm.of("E", INT, 2); - ResourceVariable f = EvaluatableTerm.of("F", INT, 2); - ResourceVariable g = EvaluatableTerm.of("G", INT, 1); + ResourceVariable a = new ResourceVariable("A", INT, 2); + ResourceVariable b = new ResourceVariable("B", INT, 2); + ResourceVariable c = new ResourceVariable("C", INT, 2); + ResourceVariable d = new ResourceVariable("D", INT, 2); + ResourceVariable e = new ResourceVariable("E", INT, 2); + ResourceVariable f = new ResourceVariable("F", INT, 2); + ResourceVariable g = new ResourceVariable("G", INT, 1); - EvaluatableTerm te1 = EvaluatableTerm.of(a, b, c); - EvaluatableTerm te2 = EvaluatableTerm.of(te1, d, e); - EvaluatableTerm te3 = EvaluatableTerm.of(te2, f, g); + EvaluatableTerm te1 = new DependencyTerm(a, b, c); + EvaluatableTerm te2 = new DependencyTerm(te1, d, e); + EvaluatableTerm te3 = new DependencyTerm(te2, f, g); MetaEvaluatableTermVariable metaTerm = new MetaEvaluatableTermVariable(new Variable("x")); MetaResourceVariable metaA = new MetaResourceVariable(new Variable("ma"));